设计模式学习日记三(持续更新)

本篇介绍Domain Model模式，一个银行领域建模，涉及帐号的创建以及帐号之间的现金转账的小程序。

1. POCO 和 PI

前面提到过，Domain Model 与 Active Record 模式不同，它不知道持久化。术语持久化(persistence ignorance,PI)表示普通CLR对象(plain old common runtime object,POCO)业务实体的朴实本质。通常Repository模式(后续中将会介绍该模式)将 Domain Model 的业务对象持久化。

2. 示例程序

创建名为Terminator.Practice.DomainModel的解决方案，并添加下面的类库项目：

Terminator.Practice.DomainModel.Model -- 包含应用程序内所有的业务逻辑。领域对象将存放在此处，并与其他对象建立关系，从而表示应用程序正则构建的银行领域。该项目还将以接口的形式为领域对象持久化和检索定义契约，采用Repository模式来实现所有的持久化管理需求。Model项目不会引用其他任何项目，从而确保：让它与任何基础设施关注点保持隔离，只关注业务领域。

Terminator.Practice.DomainModel.AppService -- 充当应用程序的接口(API)。表示层将通过消息(简单的数据传输对象，后续中将会介绍消息传送模式)与 AppService 通信。AppService 还将定义视图模型，这些是领域模型的展开视图，只用于数据显示(后续中将会更详细的介绍该方式)。

Terminator.Practice.DomainModel.Repository -- 包含Model项目中定义的资源库接口的具体实现。Repository引用了Model项目，从而从数据库提取并持久化领域对象，Repository项目只关注领域对象持久化和检索的责任。

添加一个新的Web应用程序 Terminator.Practice.DomainModel.UI.Web -- Web项目负责应用程序的表示和用户体验需求，这个项目只与

AppService交互，并接收专门为用户体验视图创建的强类型视图模型。

对Repository项目添加对Model项目的引用，AppService项目添加对Model和Repository项目的引用，Web项目添加对AppService项目的引用。

创建名为BankAccount.mdf的数据库，创建两张表：

BankAccounts表

列名	数据类型	是否允许空
BankAccountId	uniqueidentifier,Primary key	False
Balance	money	False
CustomerRef	nvarchar(50)	False

Transactions表

列名	数据类型	是否允许空
BankAccountId	uniqueidentifier	False
Deposit	money	False
Withdrawal	money	False
Reference	nvarchar(50)	False
Date	datetime	False

现在开始领域建模，在这个场景中，BankAccount为发生的每个动作创建一个Transaction对象，类似于操作日志的功能。

在Model项目中添加一个新类Transaction：

Transaction类代码

 1 using System;
 2 
 3 namespace Terminator.Practice.DomainModel.Model
 4 {
 5     public class Transaction
 6     {
 7         public Transaction(decimal deposit, decimal withdrawal, string reference, DateTime date)
 8         {
 9             Deposit = deposit;
10             Withdrawal = withdrawal;
11             Reference = reference;
12             Date = date;
13         }
14 
15         /// <summary>
16         /// 存款金额
17         /// </summary>
18         public decimal Deposit
19         { get; internal set; }
20         /// <summary>
21         /// 取出金额
22         /// </summary>
23         public decimal Withdrawal
24         { get; internal set; }
25 
26         public string Reference
27         { get; internal set; }
28 
29         public DateTime Date
30         { get; internal set; }
31     }
32 }

注：Transaction对象被称为值对象，这是DDD(领域驱动设计)中的一个术语，后续中将会介绍DDD。

添加第二个类 BankAccount：

BankAccount类代码

 1 using System;
 2 using System.Collections.Generic;
 3 
 4 namespace Terminator.Practice.DomainModel.Model
 5 {
 6     public class BankAccount
 7     {
 8         private readonly IList<Transaction> _transactions;
 9 
10         public BankAccount() : this(Guid.NewGuid(), 0, new List<Transaction>(), "")
11         {
12             _transactions.Add(new Transaction(0m, 0m, "account created", DateTime.Now));
13         }
14 
15         public BankAccount(Guid Id, decimal balance, IList<Transaction> transactions, string customerRef)
16         {
17             AccountNo = Id;
18             Balance = balance;
19             _transactions = transactions;
20             CustomerRef = customerRef;
21         }
22 
23         public Guid AccountNo { get; internal set; }
24         /// <summary>
25         /// 账户金额
26         /// </summary>
27         public decimal Balance { get; internal set; }
28 
29         public string CustomerRef { get; set; }
30 
31         /// <summary>
32         /// 是否可以取出某个金额
33         /// </summary>
34         /// <param name="amount"></param>
35         /// <returns></returns>
36         public bool CanWithdraw(decimal amount)
37         {
38             return (Balance >= amount);
39         }
40 
41         /// <summary>
42         /// 取出某金额
43         /// </summary>
44         /// <param name="amount"></param>
45         /// <param name="reference"></param>
46         public void Withdraw(decimal amount, string reference)
47         {
48             if (!CanWithdraw(amount))
49             {
50                 throw new InsufficientFundsException();
51             }
52             Balance -= amount;
53             _transactions.Add(new Transaction(0m, amount, reference, DateTime.Now));
54         }
55 
56         /// <summary>
57         /// 存款
58         /// </summary>
59         /// <param name="amount"></param>
60         /// <param name="reference"></param>
61         public void Deposit(decimal amount, string reference)
62         {
63             Balance += amount;
64             _transactions.Add(new Transaction(amount, 0m, reference, DateTime.Now));
65         }
66 
67         public IEnumerable<Transaction> GetTransactions()
68         {
69             return _transactions;
70         }
71     }   
72 }

BankAccount类有3个简单的方法：CanWithdraw，Withdraw，Deposit。因为有一个CanWithdraw方法，所以应该期望调用代码在尝试从某个帐号取出现金时使用Test-Doer(先测试再执行)模式：

if(myBankAccount.CanWithdraw(amount))
{
    myBankAccount.Withdraw(amount);
}

如果在不进行检查的情况下对一个没有足够现金金额的帐号使用Withdraw方法，则应该抛出一个异常，为此，定义一个异常类，向Model项目添加InsufficientFundsException类：

using System;

namespace Terminator.Practice.DomainModel.Model
{
    public class InsufficientFundsException : ApplicationException 
    {
    }
}

现在需要某种方法来持久化BankAccount和Transaction，因为不希望污染Domain Model项目，所以添加Repository的接口来定义契约，以满足实体的持久化和检索需求，这就是前面提到的PI和POCO的概念。

创建一个带有如下契约的接口IBankAccountRepository：

using System;
using System.Collections.Generic;

namespace Terminator.Practice.DomainModel.Model
{
    public interface IBankAccountRepository
    {
        void Add(BankAccount bankAccount);
        void Save(BankAccount bankAccount);
        IEnumerable<BankAccount> FindAll();
        BankAccount FindBy(Guid AccountId);
    }
}

向Model项目中添加BankAccountService类：

using System;

namespace Terminator.Practice.DomainModel.Model
{
    public class BankAccountService
    {
        private readonly IBankAccountRepository _bankAccountRepository;

        public BankAccountService(IBankAccountRepository bankAccountRepository)
        {
            _bankAccountRepository = bankAccountRepository;
        }
        
        public void Transfer(Guid accountNoTo, Guid accountNoFrom, decimal amount)
        {
            BankAccount bankAccountTo = _bankAccountRepository.FindBy(accountNoTo);
            BankAccount bankAccountFrom = _bankAccountRepository.FindBy(accountNoFrom);

            if (!bankAccountFrom.CanWithdraw(amount))
            {
                throw new InsufficientFundsException();
            }
            bankAccountTo.Deposit(amount, "From Acc " + bankAccountFrom.CustomerRef + " ");
            bankAccountFrom.Withdraw(amount, "Transfer To Acc " + bankAccountTo.CustomerRef + " ");

            _bankAccountRepository.Save(bankAccountTo);
            _bankAccountRepository.Save(bankAccountFrom);
        }      
    }
}

在BankAccountService 的当前实现中，在保存两个银行帐号之间发生的任何错误均会让数据处于非法状态，因此我们需要一个事务保护机制(本篇没有这么做)，后续中将会介绍UoW(工作单元模式)，它能够确保所有的事务作为一个原子动作进行提交，万一出现异常就回滚。

现在可以编写方法来持久化BankAccount和Transaction对象，在Repository项目添加一个BankAccountRepository类，该类将实现接口IBankAccountRepository：

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Data;
using System.Configuration;
using Terminator.Practice.DomainModel.Model;

namespace Terminator.Practice.DomainModel.Repository
{
    public class BankAccountRepository : IBankAccountRepository
    {
        private readonly string _connectionString;

        public BankAccountRepository()
        {
            _connectionString = ConfigurationManager.ConnectionStrings["BankAccountConnectionString"].ConnectionString;
        }

        public void Add(BankAccount bankAccount)
        {
            string insertSql = @"INSERT INTO BankAccounts(BankAccountID, Balance, CustomerRef)
                                            VALUES(@BankAccountID, @Balance, @CustomerRef)";
            using (SqlConnection connection = new SqlConnection(_connectionString))
            {
                SqlCommand command = connection.CreateCommand();
                command.CommandText = insertSql;

                SetCommandParametersForInsertUpdateTo(bankAccount, command);

                connection.Open();

                command.ExecuteNonQuery();
            }

            UpdateTransactionsFor(bankAccount);
        }

        public void Save(BankAccount bankAccount)
        {
            string bankAccoutnUpdateSql = "UPDATE BankAccounts " +
                                 "SET Balance = @Balance, CustomerRef= @CustomerRef " +
                                 "WHERE BankAccountID = @BankAccountID;";

            using (SqlConnection connection = new SqlConnection(_connectionString))
            {
                SqlCommand command = connection.CreateCommand();
                command.CommandText = bankAccoutnUpdateSql;

                SetCommandParametersForInsertUpdateTo(bankAccount, command);

                connection.Open();

                command.ExecuteNonQuery();
            }

            UpdateTransactionsFor(bankAccount);
        }

        private static void SetCommandParametersForInsertUpdateTo(BankAccount bankAccount, SqlCommand command)
        {
            command.Parameters.Add(new SqlParameter("@BankAccountID", bankAccount.AccountNo));
            command.Parameters.Add(new SqlParameter("@Balance", bankAccount.Balance));
            command.Parameters.Add(new SqlParameter("@CustomerRef", bankAccount.CustomerRef));
        }

        private void UpdateTransactionsFor(BankAccount bankAccount)
        {
            string deleteTransactionSQl = "DELETE Transactions WHERE BankAccountId = @BankAccountId;";

            using (SqlConnection connection = new SqlConnection(_connectionString))
            {
                SqlCommand command = connection.CreateCommand();
                command.CommandText = deleteTransactionSQl;
                command.Parameters.Add(new SqlParameter("@BankAccountID", bankAccount.AccountNo));
                connection.Open();
                command.ExecuteNonQuery();
            }

            string insertTransactionSql = "INSERT INTO Transactions " +
                                 "(BankAccountID, Deposit, Withdrawal, Reference, [Date]) VALUES " +
                                 "(@BankAccountID, @Deposit,  @Withdrawal,  @Reference, @Date)";

            foreach (Transaction tran in bankAccount.GetTransactions())
            {
                using (SqlConnection connection = new SqlConnection(_connectionString))
                {
                    SqlCommand command = connection.CreateCommand();
                    command.CommandText = insertTransactionSql;

                    command.Parameters.Add(new SqlParameter("@BankAccountID", bankAccount.AccountNo));
                    command.Parameters.Add(new SqlParameter("@Deposit", tran.Deposit));
                    command.Parameters.Add(new SqlParameter("@Withdrawal", tran.Withdrawal));
                    command.Parameters.Add(new SqlParameter("@Reference", tran.Reference));
                    command.Parameters.Add(new SqlParameter("@Date", tran.Date));

                    connection.Open();
                    command.ExecuteNonQuery();
                }
            }
        }

        public IEnumerable<BankAccount> FindAll()
        {
            IList<BankAccount> accounts;

            string queryString = "SELECT * FROM dbo.Transactions INNER JOIN " +
                                 "dbo.BankAccounts ON dbo.Transactions.BankAccountId = dbo.BankAccounts.BankAccountId " +
                                 "ORDER BY dbo.BankAccounts.BankAccountId;";

            using (SqlConnection connection = new SqlConnection(_connectionString))
            {
                SqlCommand command = connection.CreateCommand();
                command.CommandText = queryString;

                connection.Open();

                using (SqlDataReader reader = command.ExecuteReader())
                {
                    accounts = CreateListOfAccountsFrom(reader);
                }
            }
            return accounts;
        }

        private IList<BankAccount> CreateListOfAccountsFrom(IDataReader datareader)
        {
            IList<BankAccount> accounts = new List<BankAccount>();
            string id = "";
            IList<Transaction> transactions = new List<Transaction>();

            while (datareader.Read())
            {
                if (id != datareader["BankAccountId"].ToString())
                {
                    id = datareader["BankAccountId"].ToString();
                    transactions = new List<Transaction>();
                    BankAccount bankAccount = new BankAccount(new Guid(id), Decimal.Parse(datareader["Balance"].ToString()), transactions, datareader["CustomerRef"].ToString());
                    accounts.Add(bankAccount);
                }
                transactions.Add(CreateTransactionFrom(datareader));
            }

            return accounts;
        }

        private Transaction CreateTransactionFrom(IDataRecord rawData)
        {
            return new Transaction(Decimal.Parse(rawData["Deposit"].ToString()),
                                   Decimal.Parse(rawData["Withdrawal"].ToString()),
                                   rawData["Reference"].ToString(),
                                   DateTime.Parse(rawData["Date"].ToString()));
        }


        public BankAccount FindBy(Guid AccountId)
        {
            BankAccount account;

            string queryString = "SELECT * FROM dbo.Transactions INNER JOIN " +
                                 "dbo.BankAccounts ON dbo.Transactions.BankAccountId = dbo.BankAccounts.BankAccountId " +
                                 "WHERE dbo.BankAccounts.BankAccountId = @BankAccountId;";

            using (SqlConnection connection = new SqlConnection(_connectionString))
            {
                SqlCommand command = connection.CreateCommand();
                command.CommandText = queryString;

                SqlParameter Idparam = new SqlParameter("@BankAccountId", AccountId);
                command.Parameters.Add(Idparam);

                connection.Open();

                using (SqlDataReader reader = command.ExecuteReader())
                {
                    account = CreateListOfAccountsFrom(reader)[0];
                }
            }
            return account;
        }
    }
}

由于Repository项目需要访问web.config，所以需要添加对System.Configuration的引用。

注：在后续中将介绍一些常见的对象关系映射器，能够节省编写ADO.NET基础设施代码的时间

现在可以为客户端添加一个服务层，让其与系统已一种简单的方式进行交互。

在AppService项目中添加一个新文件夹 ViewModel，并向其中添加两个类BankAccountView 和 TransactionView:

using System;
using System.Collections.Generic;

namespace Terminator.Practice.DomainModel.AppService.ViewModels
{
    public class BankAccountView
    {
        public Guid AccountNo { get; set; }
        public string Balance { get; set; }
        public string CustomerRef { get; set; }
        public IList<TransactionView> Transactions { get; set; } 
    }
}

using System;

namespace Terminator.Practice.DomainModel.AppService.ViewModels
{
    public class TransactionView
    {
        public string Deposit { get; set; }
        public string Withdrawal { get; set; }
        public string Reference { get; set; }
        public DateTime Date { get; set; }
    }
}

BankAccountView 和 TransactionView 提供了领域模型用于表示的展开视图，为了将领域实体转换成数据传输视图模型，需要映射器类(后续中将会介绍一种将这个过程自动化的方法)。

在AppService项目根目录创建一个新类ViewMapper：

using System.Collections.Generic;
using Terminator.Practice.DomainModel.AppService.ViewModels;
using Terminator.Practice.DomainModel.Model;

namespace Terminator.Practice.DomainModel.AppService
{
    public static class ViewMapper
    {
        public static TransactionView CreateTransactionViewFrom(Transaction tran)
        {
            return new TransactionView
            {
                Deposit = tran.Deposit.ToString("C"),
                Withdrawal = tran.Withdrawal.ToString("C"),
                Reference = tran.Reference,
                Date = tran.Date
            };
        }

        public static BankAccountView CreateBankAccountViewFrom(BankAccount acc)
        {
            return new BankAccountView
            {
                AccountNo = acc.AccountNo,
                Balance = acc.Balance.ToString("C"),
                CustomerRef = acc.CustomerRef,
                Transactions = new List<TransactionView>()
            };
        }
    }
}

向AppService项目中再添加一个文件夹Messages，该文件夹将包含所有用来与服务层通信的Request-Reponse模式对象，因为所有的Reponse都共享一组相同的属性，所以可以创建一个基类ResponseBase：

namespace Terminator.Practice.DomainModel.AppService.Messages
{
    public abstract class ResponseBase
    {
        public bool Success { get; set; }
        public string Message { get; set; }
    }
}

Success属性表示被调用的方法是否成功运行，而Message属性包含该方法运行结果的详细信息。

在Messages文件夹添加几个类：BankAccountCreateRequest、BankAccountCreateResponse、DepositRequest、FindAllBankAccountResponse、FindBankAccountResponse、TransferRequest、TransferResponse、WithdrawalRequest

namespace Terminator.Practice.DomainModel.AppService.Messages
{
    public class BankAccountCreateRequest 
    {        
        public string CustomerName { get; set; }
    }
}

using System;

namespace Terminator.Practice.DomainModel.AppService.Messages
{
    public class BankAccountCreateResponse : ResponseBase 
    {        
        public Guid BankAccountId { get; set; }
    }
}

using System;

namespace Terminator.Practice.DomainModel.AppService.Messages
{
    public class DepositRequest
    {
        public Guid AccountId { get; set; }
        public decimal Amount { get; set; }
    }
}

using System.Collections.Generic;
using Terminator.Practice.DomainModel.AppService.ViewModels;

namespace Terminator.Practice.DomainModel.AppService.Messages
{
    public class FindAllBankAccountResponse : ResponseBase 
    {
        public IList<BankAccountView> BankAccountView { get; set; }
    }
}

using Terminator.Practice.DomainModel.AppService.ViewModels;

namespace Terminator.Practice.DomainModel.AppService.Messages
{
    public class FindBankAccountResponse : ResponseBase 
    {
        public BankAccountView BankAccount { get; set; }
    }
}

using System;

namespace Terminator.Practice.DomainModel.AppService.Messages
{
    public class TransferRequest
    {
        public Guid AccountIdTo { get; set; }
        public Guid AccountIdFrom { get; set; }
        public decimal Amount { get; set; }
    }
}

namespace Terminator.Practice.DomainModel.AppService.Messages
{
    public class TransferResponse : ResponseBase
    {        
    }
}

using System;

namespace Terminator.Practice.DomainModel.AppService.Messages
{
    public class WithdrawalRequest
    {
        public Guid AccountId { get; set; }
        public decimal Amount { get; set; }
    }
}

消息传送对象就位之后，就可以添加服务类来协调对领域实体(服务和资源库)的方法调用，在AppService项目的根目录添加一个新类ApplicationBankAccountService：

using System;
using System.Collections.Generic;
using Terminator.Practice.DomainModel.AppService.Messages;
using Terminator.Practice.DomainModel.AppService.ViewModels;
using Terminator.Practice.DomainModel.Model;
using Terminator.Practice.DomainModel.Repository;

namespace Terminator.Practice.DomainModel.AppService
{
    public class ApplicationBankAccountService
    {
        private readonly BankAccountService _bankAccountService;
        private readonly IBankAccountRepository _bankRepository;

        public ApplicationBankAccountService() :
            this(new BankAccountRepository(), new BankAccountService(new BankAccountRepository()))
        { }

        public ApplicationBankAccountService(IBankAccountRepository bankRepository, BankAccountService bankAccountService)
        {
            _bankRepository = bankRepository;
            _bankAccountService = bankAccountService;
        }

        public ApplicationBankAccountService(BankAccountService bankAccountService, IBankAccountRepository bankRepository)
        {
            _bankAccountService = bankAccountService;
            _bankRepository = bankRepository;
        }

        public BankAccountCreateResponse CreateBankAccount(BankAccountCreateRequest bankAccountCreateRequest)
        {
            BankAccountCreateResponse bankAccountCreateResponse = new BankAccountCreateResponse();
            BankAccount bankAccount = new BankAccount();

            bankAccount.CustomerRef = bankAccountCreateRequest.CustomerName;
            _bankRepository.Add(bankAccount);

            bankAccountCreateResponse.BankAccountId = bankAccount.AccountNo;
            bankAccountCreateResponse.Success = true;

            return bankAccountCreateResponse;
        }

        public void Deposit(DepositRequest depositRequest)
        {
            BankAccount bankAccount = _bankRepository.FindBy(depositRequest.AccountId);

            bankAccount.Deposit(depositRequest.Amount, "");

            _bankRepository.Save(bankAccount);
        }

        public void Withdrawal(WithdrawalRequest withdrawalRequest)
        {
            BankAccount bankAccount = _bankRepository.FindBy(withdrawalRequest.AccountId);

            bankAccount.Withdraw(withdrawalRequest.Amount, "");

            _bankRepository.Save(bankAccount);
        }

        public TransferResponse Transfer(TransferRequest request)
        {
            TransferResponse response = new TransferResponse();

            try
            {
                _bankAccountService.Transfer(request.AccountIdTo, request.AccountIdFrom, request.Amount);
                response.Success = true;
            }
            catch (InsufficientFundsException)
            {
                response.Message = "There is not enough funds in account on: " + request.AccountIdFrom.ToString();
                response.Success = false;
            }
            return response;
        }

        public FindAllBankAccountResponse GetAllBankAccounts()
        {
            FindAllBankAccountResponse FindAllBankAccountResponse = new FindAllBankAccountResponse();
            IList<BankAccountView> bankAccountViews = new List<BankAccountView>();
            FindAllBankAccountResponse.BankAccountView = bankAccountViews;

            foreach (BankAccount acc in _bankRepository.FindAll())
            {
                bankAccountViews.Add(ViewMapper.CreateBankAccountViewFrom(acc));
            }

            return FindAllBankAccountResponse;
        }

        public FindBankAccountResponse GetBankAccountBy(Guid Id)
        {
            FindBankAccountResponse bankAccountResponse = new FindBankAccountResponse();
            BankAccount acc = _bankRepository.FindBy(Id);
            BankAccountView bankAccountView = ViewMapper.CreateBankAccountViewFrom(acc);

            foreach (Transaction tran in acc.GetTransactions())
            {
                bankAccountView.Transactions.Add(ViewMapper.CreateTransactionViewFrom(tran));
            }

            bankAccountResponse.BankAccount = bankAccountView;

            return bankAccountResponse;
        }
    }
}

ApplicationBankAccountService类协调应用程序活动并将所有的业务任务委托给领域模型，该层并不包含任何业务逻辑，有助于防止任何与业务无关的代码污染领域模型项目，该层还将领域实体转换成数据传输对象，从而保护领域的内部操作，并为一起工作的表示层提供了一个易于使用的API。

为了简单起见，这里选择了简陋的依赖注入方式并对默认的构造器硬编码，以便使用已经编码的资源库领域服务实现，后续中将介绍IoC和IoC容器来提供类的依赖关系。

最后就是创建用户界面，从而能够创建帐号并执行交易。

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="Terminator.Practice.DomainModel.UI.Web._Default" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title></title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
     
     <fieldset>
        <legend>Create New Account</legend>    
     <p>        
        Customer Ref:
        <asp:TextBox ID="txtCustomerRef" runat="server"></asp:TextBox>
                
        <asp:Button ID="btCreateAccount" runat="server" Text="Create Account" 
            onclick="btCreateAccount_Click" />
    </p>
    </fieldset>
    
    <fieldset>
        <legend>Account Detail</legend> 
        <p>
        <asp:DropDownList AutoPostBack="true" ID="ddlBankAccounts" runat="server" 
                onselectedindexchanged="ddlBankAccounts_SelectedIndexChanged"></asp:DropDownList>
        </p>        
        <p>
            Account No:
            <asp:Label ID="lblAccountNo" runat="server" />
        </p>
        <p>
            Customer Ref:
            <asp:Label ID="lblCustomerRef" runat="server" />
        </p>
        <p>
            Balance:
            <asp:Label ID="lblBalance" runat="server" />
        </p>
        <p>
            Amount
        ￥<asp:TextBox ID="txtAmount" runat="server" Width="60px"></asp:TextBox>
                
        &nbsp;<asp:Button ID="btnWithdrawal" runat="server" Text="Withdrawal" 
                onclick="btnWithdrawal_Click" />
        &nbsp;<asp:Button ID="btnDeposit" runat="server" Text="Deposit" 
                onclick="btnDeposit_Click" />
        </p>
        <p>
            Transfer
        ￥<asp:TextBox ID="txtAmountToTransfer" runat="server" Width="60px"></asp:TextBox>
                
        &nbsp;to
        <asp:DropDownList AutoPostBack="true" ID="ddlBankAccountsToTransferTo" runat="server"></asp:DropDownList>
        &nbsp;<asp:Button ID="btnTransfer" runat="server" Text="Commit" 
                onclick="btnTransfer_Click" />
        </p>
        <p>
            Transactions</p>
            <asp:Repeater ID="rptTransactions" runat="server">        
                <HeaderTemplate>
                    <table>
                    <tr>
                        <td>deposit</td>
                        <td>withdrawal</td>
                        <td>reference</td>
                    </tr>
                </HeaderTemplate> 
                <ItemTemplate>
                    <tr>
                        <td><%# Eval("Deposit")  %></td>
                        <td><%# Eval("Withdrawal")  %></td>
                        <td><%# Eval("Reference")  %></td>                
                        <td><%# Eval("Date")  %></td>
                    </tr>
                </ItemTemplate> 
                <FooterTemplate>
                    </table>
                </FooterTemplate>   
            </asp:Repeater>
    </fieldset>    
    </div> 
    </form>
</body>
</html>

using System;
using System.Web.UI.WebControls;
using Terminator.Practice.DomainModel.AppService;
using Terminator.Practice.DomainModel.AppService.Messages;
using Terminator.Practice.DomainModel.AppService.ViewModels;

namespace Terminator.Practice.DomainModel.UI.Web
{
    public partial class _Default : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!Page.IsPostBack)
                ShowAllAccounts();
        }

        private void ShowAllAccounts()
        {
            ddlBankAccounts.Items.Clear();  

            FindAllBankAccountResponse response = new ApplicationBankAccountService().GetAllBankAccounts();
            ddlBankAccounts.Items.Add(new ListItem("Select An Account", ""));

            foreach (BankAccountView accView in response.BankAccountView)
            {
                ddlBankAccounts.Items.Add(new ListItem(accView.CustomerRef, accView.AccountNo.ToString()));
            }
        }

        protected void btCreateAccount_Click(object sender, EventArgs e)
        {
            BankAccountCreateRequest createAccountRequest = new BankAccountCreateRequest();
            createAccountRequest.CustomerName = txtCustomerRef.Text;           
            ApplicationBankAccountService service = new ApplicationBankAccountService();

            service.CreateBankAccount(createAccountRequest);   
         
            ShowAllAccounts();
        }

        protected void ddlBankAccounts_SelectedIndexChanged(object sender, EventArgs e)
        {
            DisplaySelectedAccount();
        }

        private void DisplaySelectedAccount()
        {
            if (ddlBankAccounts.SelectedValue != "")
            {
                ApplicationBankAccountService service = new ApplicationBankAccountService();
                FindBankAccountResponse response = service.GetBankAccountBy(new Guid(ddlBankAccounts.SelectedValue));
                BankAccountView accView = response.BankAccount;

                lblAccountNo.Text = accView.AccountNo.ToString();
                lblBalance.Text = accView.Balance;
                lblCustomerRef.Text = accView.CustomerRef;

                rptTransactions.DataSource = accView.Transactions;
                rptTransactions.DataBind();

                FindAllBankAccountResponse allAccountsResponse = service.GetAllBankAccounts();

                ddlBankAccountsToTransferTo.Items.Clear();

                foreach (BankAccountView acc in allAccountsResponse.BankAccountView)
                {
                    if (acc.AccountNo.ToString() != ddlBankAccounts.SelectedValue)
                        ddlBankAccountsToTransferTo.Items.Add(new ListItem(acc.CustomerRef, acc.AccountNo.ToString()));
                }
            }
        }

        protected void btnWithdrawal_Click(object sender, EventArgs e)
        {
            ApplicationBankAccountService service = new ApplicationBankAccountService();
            WithdrawalRequest request = new WithdrawalRequest();
            Guid AccId = new Guid(ddlBankAccounts.SelectedValue);
            request.AccountId = AccId;
            request.Amount = Decimal.Parse(txtAmount.Text);

            service.Withdrawal(request);
            DisplaySelectedAccount();
        }

        protected void btnDeposit_Click(object sender, EventArgs e)
        {
            ApplicationBankAccountService service = new ApplicationBankAccountService();
            DepositRequest request = new DepositRequest(); 
            Guid AccId = new Guid(ddlBankAccounts.SelectedValue);
            request.AccountId = AccId;
            request.Amount = Decimal.Parse(txtAmount.Text);

            service.Deposit(request);
            DisplaySelectedAccount();
        }

        protected void btnTransfer_Click(object sender, EventArgs e)
        {
            ApplicationBankAccountService service = new ApplicationBankAccountService();
            TransferRequest request = new TransferRequest();            
            request.AccountIdFrom = new Guid(ddlBankAccounts.SelectedValue);
            request.AccountIdTo = new Guid(ddlBankAccountsToTransferTo.SelectedValue);
            request.Amount = Decimal.Parse(txtAmountToTransfer.Text);

            service.Transfer(request);
            DisplaySelectedAccount();
            
        }
    }
}

//------------------------------------------------------------------------------
// <自动生成>
//     此代码由工具生成。
//
//     对此文件的更改可能会导致不正确的行为，并且如果
//     重新生成代码，这些更改将会丢失。 
// </自动生成>
//------------------------------------------------------------------------------

namespace Terminator.Practice.DomainModel.UI.Web {
    
    
    public partial class _Default {
        
        /// <summary>
        /// form1 控件。
        /// </summary>
        /// <remarks>
        /// 自动生成的字段。
        /// 若要进行修改，请将字段声明从设计器文件移到代码隐藏文件。
        /// </remarks>
        protected global::System.Web.UI.HtmlControls.HtmlForm form1;
        
        /// <summary>
        /// txtCustomerRef 控件。
        /// </summary>
        /// <remarks>
        /// 自动生成的字段。
        /// 若要进行修改，请将字段声明从设计器文件移到代码隐藏文件。
        /// </remarks>
        protected global::System.Web.UI.WebControls.TextBox txtCustomerRef;
        
        /// <summary>
        /// btCreateAccount 控件。
        /// </summary>
        /// <remarks>
        /// 自动生成的字段。
        /// 若要进行修改，请将字段声明从设计器文件移到代码隐藏文件。
        /// </remarks>
        protected global::System.Web.UI.WebControls.Button btCreateAccount;
        
        /// <summary>
        /// ddlBankAccounts 控件。
        /// </summary>
        /// <remarks>
        /// 自动生成的字段。
        /// 若要进行修改，请将字段声明从设计器文件移到代码隐藏文件。
        /// </remarks>
        protected global::System.Web.UI.WebControls.DropDownList ddlBankAccounts;
        
        /// <summary>
        /// lblAccountNo 控件。
        /// </summary>
        /// <remarks>
        /// 自动生成的字段。
        /// 若要进行修改，请将字段声明从设计器文件移到代码隐藏文件。
        /// </remarks>
        protected global::System.Web.UI.WebControls.Label lblAccountNo;
        
        /// <summary>
        /// lblCustomerRef 控件。
        /// </summary>
        /// <remarks>
        /// 自动生成的字段。
        /// 若要进行修改，请将字段声明从设计器文件移到代码隐藏文件。
        /// </remarks>
        protected global::System.Web.UI.WebControls.Label lblCustomerRef;
        
        /// <summary>
        /// lblBalance 控件。
        /// </summary>
        /// <remarks>
        /// 自动生成的字段。
        /// 若要进行修改，请将字段声明从设计器文件移到代码隐藏文件。
        /// </remarks>
        protected global::System.Web.UI.WebControls.Label lblBalance;
        
        /// <summary>
        /// txtAmount 控件。
        /// </summary>
        /// <remarks>
        /// 自动生成的字段。
        /// 若要进行修改，请将字段声明从设计器文件移到代码隐藏文件。
        /// </remarks>
        protected global::System.Web.UI.WebControls.TextBox txtAmount;
        
        /// <summary>
        /// btnWithdrawal 控件。
        /// </summary>
        /// <remarks>
        /// 自动生成的字段。
        /// 若要进行修改，请将字段声明从设计器文件移到代码隐藏文件。
        /// </remarks>
        protected global::System.Web.UI.WebControls.Button btnWithdrawal;
        
        /// <summary>
        /// btnDeposit 控件。
        /// </summary>
        /// <remarks>
        /// 自动生成的字段。
        /// 若要进行修改，请将字段声明从设计器文件移到代码隐藏文件。
        /// </remarks>
        protected global::System.Web.UI.WebControls.Button btnDeposit;
        
        /// <summary>
        /// txtAmountToTransfer 控件。
        /// </summary>
        /// <remarks>
        /// 自动生成的字段。
        /// 若要进行修改，请将字段声明从设计器文件移到代码隐藏文件。
        /// </remarks>
        protected global::System.Web.UI.WebControls.TextBox txtAmountToTransfer;
        
        /// <summary>
        /// ddlBankAccountsToTransferTo 控件。
        /// </summary>
        /// <remarks>
        /// 自动生成的字段。
        /// 若要进行修改，请将字段声明从设计器文件移到代码隐藏文件。
        /// </remarks>
        protected global::System.Web.UI.WebControls.DropDownList ddlBankAccountsToTransferTo;
        
        /// <summary>
        /// btnTransfer 控件。
        /// </summary>
        /// <remarks>
        /// 自动生成的字段。
        /// 若要进行修改，请将字段声明从设计器文件移到代码隐藏文件。
        /// </remarks>
        protected global::System.Web.UI.WebControls.Button btnTransfer;
        
        /// <summary>
        /// rptTransactions 控件。
        /// </summary>
        /// <remarks>
        /// 自动生成的字段。
        /// 若要进行修改，请将字段声明从设计器文件移到代码隐藏文件。
        /// </remarks>
        protected global::System.Web.UI.WebControls.Repeater rptTransactions;
    }
}

 web.config数据库连接字符串配置

  <connectionStrings>
    <add name="BankAccountConnectionString"
             connectionString="Data Source=.\SQLEXPRESS;AttachDbFilename=|DataDirectory|\BankAccount.mdf;Integrated Security=True;User Instance=True"
             providerName="System.Data.SqlClient"/>
  </connectionStrings>

解决方案结构图

程序运行图：

最后附上demo源码