使用Apworks开发基于CQRS架构的应用程序（五）：命令

客户端程序通过命令告知系统“应该做什么”。事实上，这是一种单向的交互过程，客户端程序仅仅向领域模型发送命令请求，它们并不会通过领域模型来查询某些数据信息。在CQRS架构的应用程序中，“查询”是另一部分的内容，这将在接下来的章节中单独讨论。当应用服务器端接收到来自客户端的命令请求后，就会将这些命令推送到命令总线。命令处理器会侦听命令总线，并相应地处理命令请求。现在，让我们在TinyLibraryCQRS解决方案中创建命令与命令解释器。

1. 右键单击TinyLibraryCQRS解决方案，单击 Add | New Project… 菜单，这将打开Add New Project对话框
2. 在Installed Templates选项卡下，选择Visual C# | Windows，然后选择Class Library，确保所选的.NET版本是.NET Framework 4，然后在Name文本框中，输入TinyLibrary.Commands，并单击OK按钮
3. 在TinyLibrary.Commands项目上，右键单击References节点，单击Add Reference…菜单，这将打开Add Reference对话框
4. 在.NET选项卡下，选择Apworks，然后单击OK按钮
5. 添加下面的代码：
   

   using System;
   using Apworks.Commands;
   
   namespace TinyLibrary.Commands
   {
       [Serializable]
       public class BorrowBookCommand : Command
       {
           public long ReaderId { get; set; }
           public long BookId { get; set; }
   
           public BorrowBookCommand(long readerId, long bookId)
           {
               this.ReaderId = readerId;
               this.BookId = bookId;
           }
       }
   
       [Serializable]
       public class CreateBookCommand : Command
       {
           public string Title { get; private set; }
           public string Publisher { get; private set; }
           public DateTime PubDate { get; private set; }
           public string ISBN { get; private set; }
           public int Pages { get; private set; }
           public bool Lent { get; private set; }
   
           public CreateBookCommand(string title,
               string publisher,
               DateTime pubDate,
               string isbn, int pages, bool lent)
           {
               this.Title = title;
               this.PubDate = pubDate;
               this.Publisher = publisher;
               this.ISBN = isbn;
               this.Pages = pages;
               this.Lent = lent;
           }
   
           public CreateBookCommand(long id,
               string title,
               string publisher,
               DateTime pubDate,
               string isbn, int pages, bool lent)
               : base(id)
           {
               this.Title = title;
               this.PubDate = pubDate;
               this.Publisher = publisher;
               this.ISBN = isbn;
               this.Pages = pages;
               this.Lent = lent;
           }
       }
   
       [Serializable]
       public class RegisterReaderCommand : Command
       {
           public string LoginName { get; private set; }
           public string Name { get; private set; }
   
           public RegisterReaderCommand(string loginName, string name)
           {
               this.LoginName = loginName;
               this.Name = name;
           }
   
           public RegisterReaderCommand(long id, string loginName, string name):base(id)
           {
               this.LoginName = loginName;
               this.Name = name;
           }
       }
   
       [Serializable]
       public class ReturnBookCommand : Command
       {
           public long ReaderId { get; set; }
           public long BookId { get; set; }
   
           public ReturnBookCommand(long readerId, long bookId)
           {
               this.ReaderId = readerId;
               this.BookId = bookId;
           }
       }
   }

看上去命令类与领域事件类的结构非常相似，的确如此，它们同样是继承于某个基类，同样都应用了System.SerializableAttribute特性。但事实上，命令与领域事件是两种完全不同的语义，虽然在某些情况下，两者结构相似，但这不是必然结果。

命令处理器用来处理已经定义的命令。当整个系统启动的时候，它会将Apworks配置文件里已经定义的命令处理器注册到系统中。有关这个配置文件的具体内容会在后续章节中描述。现在，我们创建一些命令处理器来处理上面已定义的命令。

1. 在Solution Explorer中右键单击TinyLibraryCQRS解决方案，然后单击Add | New Project…菜单，这将打开Add New Project对话框
2. 在Installed Templates选项卡下，选择Visual C# | Windows，然后选择Class Library，确保选择的.NET版本是.NET Framework 4，然后在Name文本框中，输入TinyLibrary.CommandHandlers，然后单击OK按钮
3. 在Solution Explorer中，右键单击TinyLibrary.CommandHandlers项目的References节点，然后选择Add Reference…菜单，这将打开Add Reference对话框
4. 在.NET选项卡下，选择Apworks然后单击OK按钮
5. 在Solution Explorer中，右键单击TinyLibrary.CommandHandlers项目的References节点，然后选择Add Reference…菜单，这将打开Add Reference对话框
6. 在Projects选项卡下，选择TinyLibrary.Commands和TinyLibrary.Domain项目，然后单击OK按钮
7. 向该项目添加以下代码
   

   using Apworks.Commands;
   using Apworks.Repositories;
   using TinyLibrary.Commands;
   using TinyLibrary.Domain;
   
   namespace TinyLibrary.CommandHandlers
   {
       public class BorrowBookCommandHandler : CommandHandler<BorrowBookCommand>
       {
           public override bool Handle(BorrowBookCommand command)
           {
               using (IDomainRepository repository = this.GetDomainRepository())
               {
                   Reader reader = repository.Get<Reader>(command.ReaderId);
                   Book book = repository.Get<Book>(command.BookId);
                   reader.BorrowBook(book);
                   repository.Save(reader);
                   repository.Save(book);
               }
               return true;
           }
       }
   
       public class CreateBookCommandHandler : CommandHandler<CreateBookCommand>
       {
           public override bool Handle(CreateBookCommand command)
           {
               using (IDomainRepository repository = this.GetDomainRepository())
               {
                   Book book = Book.Create(command.Id,
                       command.Title,
                       command.Publisher,
                       command.PubDate,
                       command.ISBN,
                       command.Pages,
                       command.Lent);
                   repository.Save<Book>(book);
               }
               return true;
           }
       }
   
       public class RegisterReaderCommandHandler : CommandHandler<RegisterReaderCommand>
       {
           public override bool Handle(RegisterReaderCommand command)
           {
               using (IDomainRepository repository = this.GetDomainRepository())
               {
                   Reader reader = Reader.Create(command.Id, command.LoginName, command.Name);
                   repository.Save(reader);
               }
               return true;
           }
   
       }
   
       public class ReturnBookCommandHandler : CommandHandler<ReturnBookCommand>
       {
           public override bool Handle(ReturnBookCommand command)
           {
               using (IDomainRepository repository = this.GetDomainRepository())
               {
                   Reader reader = repository.Get<Reader>(command.ReaderId);
                   Book book = repository.Get<Book>(command.BookId);
                   reader.ReturnBook(book);
                   repository.Save(reader);
                   repository.Save(book);
               }
               return true;
           }
       }
   }

从上面的代码我们可以看到，所有的命令处理器都从CommandHandler泛型抽象类继承而来，同时实现其Handle方法。通常，在Handle方法中，命令处理器会根据命令的具体内容，通过领域仓储来获得或更新聚合。要得到领域仓储的实例，可以使用定义在CommandHandler基类中的GetDomainRepository方法。建议在GetDomainRepository的调用端使用using子句以便及时释放资源。

就如我们上面讨论的那样，每当系统得到一个命令时，都将把它推送到命令总线中。当总线被提交的时候，已注册的命令处理器会处理与之对应的命令请求。现在，我们需要创建一个应用级的服务外观来接收客户端命令请求。在TinyLibraryCQRS解决方案中，这个应用服务外观被定义成了一个.NET WCF服务。下一讲将介绍这个.NET WCF服务的创建过程。