ASP.NET 简洁论坛源码分析之 - EntityEngine流程分析 转

ASP.NET 简洁论坛源码最新版本下载地址：

http://files.cnblogs.com/netfocus/forum.rar

演示地址：

http://www.silks.cc/

隔了很长时间，终于又有时间可以坐下来写写文章了。按照大纲的顺序，今天介绍整个实体引擎（EntityEngine）的设计，以及如何使用它来完成各种数据库操作。首先来看一下EntityEngine引擎中相关的几个关键的类。

当用户要对数据库做某个操作时，需要先创建一个EntityRequest实例，然后将该实例传给RequestBuilder，RequestBuilder会对该实例做进一步的一些通用的初始化操作，比如设置请求的类型。EntityRequest创建完成后，根据该EntityRequest实例进一步创建一个RequestBinder实例，该实例的作用是将当前的EntityRequest实例和一个EntityReply实例绑定起来。然后框架就会把这个RequestBinder实例发送传给EntityEngine引擎，EntityEngine引擎调用EntityManager来处理请求，而EntityManager则调用一个EntityProvider实例来真正操作数据库。请求执行完成后，会更新EntityReply实例，EntityReply中包含了一个Entity实例，这个Entity实例可以是任意数据，可以是单个实体，也可以是一个集合。以上就是EntityEngine引擎的大致执行流程。

下面再明确列一下这几个类的主要职责或作用：

EntityRequest：提供一个类，用来表示用户的请求，存放请求的一切相关数据；

RequestBuilder：设置请求类型，或者根据一些参数来创建一个请求（EntityRequest）；

RequestBinder：将请求和一个回复（EntityReply）捆绑，即建立对应关系；

EntityEngine：发送一个请求，当然实际上发送的是RequestBinder；

EntityManager：一个实体管理类，提供如CRUD等操作，它内部调用一个EntityProvider实例来完成真正的数据库操作；

EntityProvider：它是一个Provider实例，提供了操作数据库的统一接口，该类会调用ADO.NET完成数据库的操作；

EntityReply：表示请求的回复，一个EntityRequest对应一个EntityReply；EntityReply中包含了请求的所有结果信息；

Entity：一个抽象类，一个应用中所有的真实实体类都继承自它，它能表示单个实体对象，也能表示一个集合对象；

EntityList：表示一个包含多个Entity的集合，但它也是集成自Entity的；

 

好了，了解了EntityEngine引擎的大致流程以及每个关键类的功能后，我想就可以举个简单的例子来说明具体应该如何来使用这些类。就以发表帖子这个功能来举例吧：

1.在ThreadAdd.cs文件中，当用户点击发帖按钮后，会执行SaveThread方法，该函数首先创建一个Thread实例，即创建一个帖子实例，然后设置帖子的相关信息，然后调用BusinessManager.CreateThread方法来创建帖子到数据库。代码如下：

Code
 1private void SaveThread(object sender, EventArgs e)
 2{
 3    //检查版块是否存在
 4    if (section == null)
 5    {
 6        throw new Exception("请确认您所在的版块是存在的。");
 7    }
 8
 9    //获取当前帖子
10    Thread thread = new Thread();
11
12    //设置帖子属性
13    thread.GroupId.Value = section.GroupId.Value;
14    thread.SectionId.Value = section.EntityId.Value;
15    thread.Subject.Value = subjectTextBox.Value;
16    thread.ThreadMarks.Value = int.Parse(threadMarksTextBox.Value);
17    thread.Body.Value = bodyEditor.Value;
18    thread.ThreadStatus.Value = (int)ThreadStatus.Normal;
19    thread.AuthorId.Value = CurrentUser.EntityId.Value;
20    thread.Author.Value = CurrentUser.NickName.Value == null ? "" : CurrentUser.NickName.Value;
21    thread.CreateDate.Value = DateTime.Now;
22    thread.UpdateDate.Value = DateTime.Now;
23    thread.StickDate.Value = DateTime.Parse("1753-01-01");
24    thread.TotalViews.Value = 0;
25
26    //添加帖子
27    BusinessManager.CreateThread(thread);
28
29    //返回列表页面
30    Page.Response.Redirect(SiteUrls.Instance.GetThreadsUrl((int)ThreadOrderType.UpdateDate,
31        (int)ThreadStatus.Normal, (int)ThreadReleaseStatus.Open, section.EntityId.Value));
32}

 

2. BusinessManager.cs文件：

1  private   static  EntityEngine entityEngine  =   new  EntityEngine();
2    public   static   void  CreateThread(Thread thread)
3  {
4      entityEngine.ExecuteRequest(RequestHelper.BuildAddThreadRequest(thread));
5  }

该方法的实现非常简单，就是调用RequestHelper创建一个RequestBinder实例，然后直接调用一个静态的EntityEngine实例的ExecuteRequest静态方法。前面说过，EntityEngine主要负责接收并发送RequestBinder。接下来再看看RequestHelper是如何创建一个RequestBinder的？

3. RequestHelper.cs文件：

Code
1 public static BaseRequestBinder BuildAddThreadRequest(Thread thread)
2 {
3     return new TBaseRequestBinder<ThreadReply, AddOperation>
4     (
5         RequestBuilder.BuildAddEntityRequest<ThreadRequest>(thread)
6     );
7 }

这个函数也非常简单，首先将刚才创建的Thread实例传给RequstBuilder类的静态方法BuildAddEntityRequest方法，然后该方法就返回一个EntityRequest的实例，然后再把这个实例传给RequestBinder的构造函数，最终创建出一个RequestBinder实例；下面在看看RequestBuilder的BuildAddEntityRequest做了什么呢？

4. RequestBuilder.cs文件：

Code
1 public static TRequest BuildAddEntityRequest<TRequest>(Entity entity) where TRequest : EntityRequest, new()
2 {
3     TRequest request = new TRequest();
4     request.Operation = OperationType.Add;
5     request.Entity = entity;
6     return request;
7 }

由于用到了泛型，所以根据动态传入进来的类型创建一个EntityRequest实例，在这个例子中就是ThreadRequest。另外由于是新增的操作，所以还要再将该Request标记为Add，然后就是将要保存的Thread实例保存到EntityRequest中，以便告诉框架要保存的信息。好，现在对EntityRequest是如何创建出来的应该有所了解了，先看接下去看看这个Request是如何被发送和执行的。接下来转到EntityEngine的ExecuteRequest方法，该方法负责接收和发送Request。

5. EntityEngine.cs文件：

1  ///   <summary>
2    ///  同步发送单个给定的请求，并直接返回请求结果.
3  ///   </summary>
4  public  BaseReply ExecuteRequest(BaseRequestBinder requestBinder)
5  {
6       return  requestBinder.ExecuteRequest();
7  }

该方法的实现非常简单，就是直接调用RequestBinder的ExecuteRequest方法发送Request。

6. RequestBinder.cs文件：

1  public   override  BaseReply ExecuteRequest()
2  {
3       return  Request.Send( this );
4  }

前面分析过，一个RequestBinder会将一个Request和一个Reply进行捆绑。所以它自然会至少包含对这两个实例的引用。

而它的ExecuteRequest方法也非常简单，直接调用Request实例的Send方法去发送Request，当然发送时需要将RequestBinder实例的引用传递进去，因为在EntityManager处理一个Request的时候，会把相应的返回信息保存到当前Request对应的Reply中。下面看看EntityRequest是如何发送请求的。

7. EntityRequest.cs文件：

 1  public   override  BaseReply Send(BaseRequestBinder requestBinder)
 2  {
 3      BaseReply reply  =  requestBinder.Reply;
 4      SqlResult result;
 5 
 6       switch  (Operation)
 7      {
 8           case  OperationType.Get:
 9              reply.Reply  =  EntityManager.GetEntity(requestBinder);
10               break ;
11           case  OperationType.Add:
12              result  =  EntityManager.CreateEntity(requestBinder);
13              reply.Status  =  result.Status;
14              reply.Log  =  result.Message;
15               break ;
16           case  OperationType.Update:
17              result  =  EntityManager.UpdateEntity(requestBinder);
18              reply.Status  =  result.Status;
19              reply.Log  =  result.Message;
20               break ;
21           case  OperationType.Delete:
22              result  =  EntityManager.DeleteEntity(requestBinder);
23              reply.Status  =  result.Status;
24              reply.Log  =  result.Message;
25               break ;
26      }
27 
28       return  reply;
29  }

从代码中可以清晰的看到，首先根据当前Request的请求类型，如添加、删除、修改、查询等，来决定该调用EntityManager的哪个接口来处理请求。这里可以看到EntityManager提供了四个简单明了的接口分别用来查询单个实体、添加单个实体、更新单个实体、删除单个实体。在这个例子中，我们会进入Add的分支，也就是调用CreateEntity接口。下面就来看看CreateEntity接口如何实现的。

8. EntityManager.cs文件：

1  private   static  EntityProvider entityProvider  =  Configuration.Instance.Providers[ " EntityProvider " ]  as  EntityProvider;
2  public   static  SqlResult CreateEntity(BaseRequestBinder requestBinder)
3  {
4       return  entityProvider.CreateEntity(requestBinder);
5  }

完全跟前面分析流程的一致，EntityManager直接调用EntityProvider的CreateEntity来真正去删除一个实体，在这个例子中就是去添加一个帖子到数据库；接下来转到EntityProvider中去看看CreateEntity接口是如何实现的。

9. SqlEntityProvider.cs文件：

1  public   override  SqlResult CreateEntity(BaseRequestBinder requestBinder)
2  {
3       return  CreateEntity(GetConnection(), requestBinder);
4  }

该方法也非常简单，仅仅一句话。所有的代码都交给了CreateEntity的一个私有方法来完成，下面继续看看该私有方法：

 

 1  private  SqlResult CreateEntity(SqlConnection connection, SqlTransaction transaction, BaseRequestBinder requestBinder)
 2  {
 3      SqlResult result  =   new  SqlResult();
 4 
 5      EntityRequest request  =  requestBinder.Request  as  EntityRequest;
 6 
 7       if  (request  !=   null )
 8      {
 9           if  ( ! string .IsNullOrEmpty(request.CommandIdent))
10          {
11              result  =  ExecuteRequest(connection, transaction,
12                  Configuration.Instance.GetCommand(request.CommandIdent), requestBinder, request);
13          }
14           else   if  (request.Entity  !=   null )
15          {
16              result  =  ExecuteRequest(connection, transaction,
17                  Configuration.Instance.GetCreateCommand(request.Entity.GetType()), requestBinder, request.Entity);
18          }
19      }
20       return  result;
21  }

该方法看上去有些复杂，但可以看的出来，它还不是真正执行数据库操作的地方，真正执行数据库操作的都由ExecuteRequest私有方法来完成了。但需要简单介绍下的是，这里有一个判断，就是判断当前Request是否提供了一个CommandIdent，如果有提供就进入上面的分支，如果未提供就进入下面的分支。这个判断的意思是：如果提供了CommandIdent，则说明告诉框架需要去调用一个存储过程来执行该请求，CommandIdent标识了该存储过程对应的一个映射的名称；如果未提供，则调用框架提供的默认的新增实体的方法去将该实体插入到表中。上面代码中的GetCommand和GetCreateCommand会利用预先配置好的ORMapping映射信息去获取一个存储过程的所有信息，并把当前Request中的数据设置到存储过程的参数中。这一切都是自动的，因为所有对应关系都已经在一个ORMapping.xml的配置文件中配置好了。下面继续看看ExecuteRequest这个私有函数做了什么？

 1  private  SqlResult ExecuteRequest(SqlConnection connection, SqlTransaction transaction, Command command,
 2      BaseRequestBinder requestBinder,  object  commandData)
 3  {
 4      SqlResult result  =   new  SqlResult();
 5 
 6       try
 7      {
 8          SqlCommand sqlCommand  =   new  SqlCommand(command.CommandName, connection);
 9 
10          sqlCommand.Transaction  =  transaction;
11          sqlCommand.CommandType  =  CommandType.StoredProcedure;
12 
13          SetCommandParameters(command, sqlCommand);
14 
15          SqlParameter parameter  =   new  SqlParameter();
16          parameter.ParameterName  =   " @ReturnValue " ;
17          parameter.SqlDbType  =  SqlDbType.Int;
18          parameter.Size  =   4 ;
19          parameter.Direction  =  ParameterDirection.ReturnValue;
20          sqlCommand.Parameters.Add(parameter);
21 
22           if  (commandData  is  Entity)
23          {
24              SetParameterValues(command, sqlCommand, (Entity)commandData);
25          }
26           else   if  (commandData  is  EntityRequest)
27          {
28              SetParameterValues(command, sqlCommand, (EntityRequest)commandData);
29          }
30           else
31          {
32               throw   new  Exception( " Command Data invalid type. " );
33          }
34 
35          sqlCommand.ExecuteNonQuery();
36 
37           if  (commandData  is  Entity)
38          {
39              SetOutputParameterValues(command, sqlCommand, (Entity)commandData);
40          }
41           else   if  (commandData  is  EntityRequest)
42          {
43              SetOutputParameterValues(command, sqlCommand, (EntityReply)requestBinder.Reply);
44          }
45 
46           if  (parameter.Value  !=   null   &&  parameter.Value  !=  DBNull.Value)
47          {
48              result.Status  =  ( int )parameter.Value;
49          }
50      }
51       catch  (Exception ex)
52      {
53          result  =   new  SqlResult();
54          result.Message  =  ex.Message;
55      }
56       finally
57      {
58           if  (transaction  ==   null )
59          {
60              CloseConnection(connection);
61          }
62      }
63 
64       return  result;
65  }

果然如此，这个函数的代码一目了然，就是一些简单的常用的ADO.NET操作的代码。首先实例化一个SqlCommand，然后设置该SqlCommand的参数信息，然后执行该SqlCommand，然后将Output的参数设置到EntityReply中，如果有的话。最后关闭数据库连接。

 

好，到这里位置，当前请求算是执行完成了，接下来看看如何获取Reply，以及如何判断当前请求执行是否成功。因为当前这个例子是发表帖子，所以我们优势常常不会去判断是否成功。因为如果默认没有发生异常的话，就简单的认为已经成功了。当然如果你真的想获取这些信息的话，就从Reply中去获取吧。下面再来看看最初发表帖子时的代码：

 1  private   void  SaveThread( object  sender, EventArgs e)
 2  {
 3       // 检查版块是否存在
 4       if  (section  ==   null )
 5      {
 6           throw   new  Exception( " 请确认您所在的版块是存在的。 " );
 7      }
 8 
 9       // 获取当前帖子
10      Thread thread  =   new  Thread();
11 
12       // 设置帖子属性
13      thread.GroupId.Value  =  section.GroupId.Value;
14      thread.SectionId.Value  =  section.EntityId.Value;
15      thread.Subject.Value  =  subjectTextBox.Value;
16      thread.ThreadMarks.Value  =   int .Parse(threadMarksTextBox.Value);
17      thread.Body.Value  =  bodyEditor.Value;
18      thread.ThreadStatus.Value  =  ( int )ThreadStatus.Normal;
19      thread.AuthorId.Value  =  CurrentUser.EntityId.Value;
20      thread.Author.Value  =  CurrentUser.NickName.Value  ==   null   ?   ""  : CurrentUser.NickName.Value;
21      thread.CreateDate.Value  =  DateTime.Now;
22      thread.UpdateDate.Value  =  DateTime.Now;
23      thread.StickDate.Value  =  DateTime.Parse( " 1753-01-01 " );
24      thread.TotalViews.Value  =   0 ;
25 
26       // 添加帖子
27      BusinessManager.CreateThread(thread);
28 
29       // 返回列表页面
30      Page.Response.Redirect(SiteUrls.Instance.GetThreadsUrl(( int )ThreadOrderType.UpdateDate,
31          ( int )ThreadStatus.Normal, ( int )ThreadReleaseStatus.Open, section.EntityId.Value));
32  }

可以看到，我在调用BusinessManager的CreateThread方法创建帖子的时候，并没有关心其返回值，我这里偷懒了，我想真正的网站不应该如此，应该如下面这样：

 

 1  private   void  SaveThread( object  sender, EventArgs e)
 2  {
 3       // 检查版块是否存在
 4       if  (section  ==   null )
 5      {
 6           throw   new  Exception( " 请确认您所在的版块是存在的。 " );
 7      }
 8 
 9       // 获取当前帖子
10      Thread thread  =   new  Thread();
11 
12       // 设置帖子属性
13      thread.GroupId.Value  =  section.GroupId.Value;
14      thread.SectionId.Value  =  section.EntityId.Value;
15      thread.Subject.Value  =  subjectTextBox.Value;
16      thread.ThreadMarks.Value  =   int .Parse(threadMarksTextBox.Value);
17      thread.Body.Value  =  bodyEditor.Value;
18      thread.ThreadStatus.Value  =  ( int )ThreadStatus.Normal;
19      thread.AuthorId.Value  =  CurrentUser.EntityId.Value;
20      thread.Author.Value  =  CurrentUser.NickName.Value  ==   null   ?   ""  : CurrentUser.NickName.Value;
21      thread.CreateDate.Value  =  DateTime.Now;
22      thread.UpdateDate.Value  =  DateTime.Now;
23      thread.StickDate.Value  =  DateTime.Parse( " 1753-01-01 " );
24      thread.TotalViews.Value  =   0 ;
25 
26       // 添加帖子
27      BaseReply reply  =  BusinessManager.CreateThread(thread);
28 
29       if  (reply.Status  !=   0 )
30      {
31           // 这里，我们可以将错误信息做任何处理，如保存到日志或显示给用户。
32           throw   new  Exception(reply.Log);
33      }
34       else
35      {
36           // 返回列表页面
37          Page.Response.Redirect(SiteUrls.Instance.GetThreadsUrl(( int )ThreadOrderType.UpdateDate,
38              ( int )ThreadStatus.Normal, ( int )ThreadReleaseStatus.Open, section.EntityId.Value));
39      }
40  }

 

好了，真个发表帖子的流程分析完了。各位有什么体会呢？是不是觉得为什么要搞出这么多层次结构的类，为什么不直接调用EntityProvider来实现功能呢？呵呵，当然如果你要这样做也可以，除非你愿意一直不断重复并且容易出错的写ADO.NET相关的代码。你可以发现，基于这一套框架，你做任何操作，都不必在代码中写SQL语句，你所要做的，仅仅是定义一些非常简单直观的实体类、定义好ORMapping配置文件、定义这些实体类相关的Request，然后再写几个业务相关的接口，这样，整个数据访问层就好了。

其实，添加、删除、修改，以及根据主键去获取单个实体，这些操作都是非常简单的。我觉得最复杂的是多条件组合查询，或者是多个请求组合起来一起执行的情况。如果我一次性全部讲清楚可能文章会非常长，所以我准备留到下面几篇，重点介绍其他很多细节但又非常关键，或者说最能体现这个实用类库价值的一些设计。

 

 

转载自:http://www.cnblogs.com/netfocus/archive/2009/11/05/1596655.html