敏捷软件开发_实例2<四>

敏捷软件开发_实例2<四>

上一章中对薪水支付案例的用例和类做了详细的阐述，在本篇会介绍薪水支付案例包的划分和数据库，UI的设计。

包的划分

一个错误包的划分

为什么这个包是错误的：

• 如果对classifications更改就要影响payrolldatabase更改，还会迫使transactions更改，tansactions重新发布和编译测试就是不负责的，transactions没有共享封闭性，每个类都有自己变化的敏感，所以发布的频率非常高，是不合理的。

调整一下：

将具体类和具体类打包，抽象类和抽象类打包，交互类单独打包。这已经是一个比较好打包设计了。

类的组件应该要符合共同重用原则，payrolldamain中的类没有形成最小的可重用单元，transaction类不必和组件中的其他类一起重用，可以把transaction迁移到transactionapplication类中

这样的划分太精细了，是否有这样的必要需要整体来看。

最终包的结构：

数据库的设计

emplogee是核心

完成这个设计需要进行重构：

• 提取出payrolldatabase接口，

    public interface PayrollDatabase
    {
        void AddEmployee(Employee employee);
        Employee GetEmployee(int id);
        void DeleteEmployee(int id);
        void AddUnionMember(int id, Employee e);
        Employee GetUnionMember(int id);
        void RemoveUnionMember(int memberId);
        ArrayList GetAllEmployeeIds();
        IList GetAllEmployees();
    }

• 内存表实例：

    public class InMemoryPayrollDatabase : PayrollDatabase
    {
        private static Hashtable employees = new Hashtable();
        private static Hashtable unionMembers = new Hashtable();
  
        public void AddEmployee(Employee employee)
        {
            employees[employee.EmpId] = employee;
        }
  
        // etc...
        public Employee GetEmployee(int id)
        {
            return employees[id] as Employee;
        }
  
        public void DeleteEmployee(int id)
        {
            employees.Remove(id);
        }
  
        public void AddUnionMember(int id, Employee e)
        {
            unionMembers[id] = e;
        }
  
        public Employee GetUnionMember(int id)
        {
            return unionMembers[id] as Employee;
        }
  
        public void RemoveUnionMember(int memberId)
        {
            unionMembers.Remove(memberId);
        }
  
        public ArrayList GetAllEmployeeIds()
        {
            return new ArrayList(employees.Keys);
        }
  
        public IList GetAllEmployees()
        {
            return new ArrayList(employees.Values);
        }
  
        public void Clear()
        {
            employees.Clear();
            unionMembers.Clear();
        }
    }

• 数据库

    public class SqlPayrollDatabase : PayrollDatabase
    {
        private SqlConnection connection;
  
        public SqlPayrollDatabase()
        {
            connection = new SqlConnection("Initial Catalog=Payroll;Data Source=localhost;user id=sa;password=abc");
            connection.Open();
        }
  
        ~SqlPayrollDatabase()
        {
            connection.Close();
        }
  
        public void AddEmployee(Employee employee)
        {
            //增加员工策略
            SaveEmployeeOperation operation = new SaveEmployeeOperation(employee, connection);
            operation.Execute();
        }
  
        public Employee GetEmployee(int id)
        {
            //数据库事务
            LoadEmployeeOperation loadOperation = new LoadEmployeeOperation(id, connection);
            loadOperation.Execute();
            return loadOperation.Employee;
        }
  
        public void DeleteEmployee(int id)
        {
            throw new NotImplementedException();
        }
  
        public void AddUnionMember(int id, Employee e)
        {
            throw new NotImplementedException();
        }
  
        public Employee GetUnionMember(int id)
        {
            throw new NotImplementedException();
        }
  
        public void RemoveUnionMember(int memberId)
        {
            throw new NotImplementedException();
        }
  
        public ArrayList GetAllEmployeeIds()
        {
            throw new NotImplementedException();
        }
  
        public IList GetAllEmployees()
        {
            throw new NotImplementedException();
        }
  
    }

• 如果插入雇佣记录成功，但是支付记录失败，为了解决这个问题而使用事务的方式。

    public class SaveEmployeeOperation
    {
        private readonly Employee employee;
        private readonly SqlConnection connection;
  
        private string methodCode;
        private string classificationCode;
        private SqlCommand insertPaymentMethodCommand;
        private SqlCommand insertEmployeeCommand;
        private SqlCommand insertClassificationCommand;
  
        public SaveEmployeeOperation(Employee employee, SqlConnection connection)
        {
            this.employee = employee;
            this.connection = connection;
        }
  
        public void Execute()
        {
            PrepareToSavePaymentMethod(employee);
            PrepareToSaveClassification(employee);
            PrepareToSaveEmployee(employee);
  
            SqlTransaction transaction = connection.BeginTransaction("Save Employee");
            try
            {
                ExecuteCommand(insertEmployeeCommand, transaction);
                ExecuteCommand(insertPaymentMethodCommand, transaction);
                ExecuteCommand(insertClassificationCommand, transaction);
                transaction.Commit();
            }
            catch(Exception e)
            {
                transaction.Rollback();
                throw e;
            }
        }
  
  
        private void ExecuteCommand(SqlCommand command, SqlTransaction transaction)
        {
            if(command != null)
            {
                command.Connection = connection;
                command.Transaction = transaction;
                command.ExecuteNonQuery();
            }
        }
  
        private void PrepareToSaveEmployee(Employee employee)
        {
            string sql = "insert into Employee values (" +
                "@EmpId, @Name, @Address, @ScheduleType, " +
                "@PaymentMethodType, @PaymentClassificationType)";
            insertEmployeeCommand = new SqlCommand(sql);
  
            this.insertEmployeeCommand.Parameters.Add("@EmpId", employee.EmpId);
            this.insertEmployeeCommand.Parameters.Add("@Name", employee.Name);
            this.insertEmployeeCommand.Parameters.Add("@Address", employee.Address);
            this.insertEmployeeCommand.Parameters.Add("@ScheduleType", ScheduleCode(employee.Schedule));
            this.insertEmployeeCommand.Parameters.Add("@PaymentMethodType", methodCode);
            this.insertEmployeeCommand.Parameters.Add("@PaymentClassificationType", classificationCode);
        }
  
        private void PrepareToSavePaymentMethod(Employee employee)
        {
            PaymentMethod method = employee.Method;
            if(method is HoldMethod)
                methodCode = "hold";
            else if(method is DirectDepositMethod)
            {
                methodCode = "directdeposit";
                DirectDepositMethod ddMethod = method as DirectDepositMethod;
                insertPaymentMethodCommand = CreateInsertDirectDepositCommand(ddMethod, employee);
            }
            else if(method is MailMethod)
            {
                methodCode = "mail";
                MailMethod mailMethod = method as MailMethod;
                insertPaymentMethodCommand = CreateInsertMailMethodCommand(mailMethod, employee);
            }
            else
                methodCode = "unknown";
        }
  
        private SqlCommand CreateInsertDirectDepositCommand(DirectDepositMethod ddMethod, Employee employee)
        {
            string sql = "insert into DirectDepositAccount values (@Bank, @Account, @EmpId)";
            SqlCommand command = new SqlCommand(sql);
            command.Parameters.Add("@Bank", ddMethod.Bank);
            command.Parameters.Add("@Account", ddMethod.AccountNumber);
            command.Parameters.Add("@EmpId", employee.EmpId);
            return command;
        }       
  
        private SqlCommand CreateInsertMailMethodCommand(MailMethod mailMethod, Employee employee)
        {
            string sql = "insert into PaycheckAddress values (@Address, @EmpId)";
            SqlCommand command = new SqlCommand(sql);
            command.Parameters.Add("@Address", mailMethod.Address);
            command.Parameters.Add("@EmpId", employee.EmpId);
            return command;
        }
  
        private void PrepareToSaveClassification(Employee employee)
        {
            PaymentClassification classification = employee.Classification;
            if(classification is HourlyClassification)
            {
                classificationCode = "hourly";
                HourlyClassification hourlyClassification = classification as HourlyClassification;
                insertClassificationCommand = CreateInsertHourlyClassificationCommand(hourlyClassification, employee);
            }
            else if(classification is SalariedClassification)
            {
                classificationCode = "salary";
                SalariedClassification salariedClassification = classification as SalariedClassification;
                insertClassificationCommand = CreateInsertSalariedClassificationCommand(salariedClassification, employee);
            }
            else if(classification is CommissionClassification)
            {
                classificationCode = "commission";
                CommissionClassification commissionClassification = classification as CommissionClassification;
                insertClassificationCommand = CreateInsertCommissionClassificationCommand(commissionClassification, employee);
            }
            else
                classificationCode = "unknown";
  
        }
  
        private SqlCommand CreateInsertHourlyClassificationCommand(HourlyClassification classification, Employee employee)
        {
            string sql = "insert into HourlyClassification values (@HourlyRate, @EmpId)";
            SqlCommand command = new SqlCommand(sql);
            command.Parameters.Add("@HourlyRate", classification.HourlyRate);
            command.Parameters.Add("@EmpId", employee.EmpId);
            return command;
        }
  
        private SqlCommand CreateInsertSalariedClassificationCommand(SalariedClassification classification, Employee employee)
        {
            string sql = "insert into SalariedClassification values (@Salary, @EmpId)";
            SqlCommand command = new SqlCommand(sql);
            command.Parameters.Add("@Salary", classification.Salary);
            command.Parameters.Add("@EmpId", employee.EmpId);
            return command;
        }
  
        private SqlCommand CreateInsertCommissionClassificationCommand(CommissionClassification classification, Employee employee)
        {
            string sql = "insert into CommissionedClassification values (@Salary, @Commission, @EmpId)";
            SqlCommand command = new SqlCommand(sql);
            command.Parameters.Add("@Salary", classification.BaseRate);
            command.Parameters.Add("@Commission", classification.CommissionRate);
            command.Parameters.Add("@EmpId", employee.EmpId);
            return command;
        }
  
        private static string ScheduleCode(PaymentSchedule schedule)
        {
            if(schedule is MonthlySchedule)
                return "monthly";
            if(schedule is WeeklySchedule)
                return "weekly";
            if(schedule is BiWeeklySchedule)
                return "biweekly";
            else
                return "unknown";
        }
    }

界面设计

界面设计时最好使得业务行为和UI分离，这里使用model view presenter模式（MVP）

• model：实体层和数据库交互
• view：界面层
• presenter：业务处理层

MVP的作用是解耦界面、业务和实体的关系

• 在presenter中主动使用view，界面的形态都是由presenter去控制，就是在presenter中去注册view事件，当用户触发事件时，这个事件会通过view传递到presenter中，并通过presenter调用model数据方法，最后presenter 调用引用的view实例去改变界面的形态。

public class AddEmployeePresenter
{
    private TransactionContainer transactionContainer;
    private AddEmployeeView view;
    private PayrollDatabase database;

    private int empId;
    private string name;
    private string address;
    private bool isHourly;
    private double hourlyRate;
    private bool isSalary;
    private double salary;
    private bool isCommission;
    private double commissionSalary;
    private double commission;

    public AddEmployeePresenter(AddEmployeeView view, 
        TransactionContainer container, 
        PayrollDatabase database)
    {
        this.view = view;
        this.transactionContainer = container;
        this.database = database;
    }

    public int EmpId
    {
        get { return empId; }
        set
        {
            empId = value;
            UpdateView();
        }
    }

    public string Name
    {
        get { return name; }
        set
        {
            name = value;
            UpdateView();
        }
    }

    public string Address
    {
        get { return address; }
        set
        {
            address = value;
            UpdateView();
        }
    }

    public bool IsHourly
    {
        get { return isHourly; }
        set
        {
            isHourly = value;
            UpdateView();
        }
    }

    public double HourlyRate
    {
        get { return hourlyRate; }
        set
        {
            hourlyRate = value;
            UpdateView();
        }
    }

    public bool IsSalary
    {
        get { return isSalary; }
        set
        {
            isSalary = value;
            UpdateView();
        }
    }

    public double Salary
    {
        get { return salary; }
        set
        {
            salary = value;
            UpdateView();
        }
    }

    public bool IsCommission
    {
        get { return isCommission; }
        set
        {
            isCommission = value;
            UpdateView();
        }
    }

    public double CommissionSalary
    {
        get { return commissionSalary; }
        set
        {
            commissionSalary = value;
            UpdateView();
        }
    }

    public double Commission
    {
        get { return commission; }
        set
        {
            commission = value;
            UpdateView();
        }
    }

    private void UpdateView()
    {
        if(AllInformationIsCollected())
            view.SubmitEnabled = true;
        else
            view.SubmitEnabled = false;
    }

    public bool AllInformationIsCollected()
    {
        bool result = true;
        result &= empId > 0;
        result &= name != null && name.Length > 0;
        result &= address != null && address.Length > 0;
        result &= isHourly || isSalary || isCommission;
        if(isHourly)
            result &= hourlyRate > 0;
        else if(isSalary)
            result &= salary > 0;
        else if(isCommission)
        {
            result &= commission > 0;
            result &= commissionSalary > 0;
        }
        return result;
    }

    public TransactionContainer TransactionContainer
    {
        get { return transactionContainer; }
    }

    public virtual void AddEmployee()
    {
        transactionContainer.Add(CreateTransaction());
    }

    public Transaction CreateTransaction()
    {
        if(isHourly)
            return new AddHourlyEmployee(
                empId, name, address, hourlyRate, database);
        else if(isSalary)
            return new AddSalariedEmployee(
                empId, name, address, salary, database);
        else
            return new AddCommissionedEmployee(
                empId, name, address, commissionSalary, 
                commission, database);
    }
}

public interface ViewLoader
{
    void LoadPayrollView();
    void LoadAddEmployeeView(
        TransactionContainer transactionContainer);
}

public class WindowViewLoader : ViewLoader
{
    private readonly PayrollDatabase database;
    private Form lastLoadedView;

    public WindowViewLoader(PayrollDatabase database)
    {
        this.database = database;
    }

    public void LoadPayrollView()
    {
        PayrollWindow view = new PayrollWindow();
        PayrollPresenter presenter = 
            new PayrollPresenter(database, this);

        view.Presenter = presenter;
        presenter.View = view; // 相互关联

        LoadView(view);
    }

    public void LoadAddEmployeeView(
        TransactionContainer transactionContainer)
    {
        AddEmployeeWindow view = new AddEmployeeWindow();
        AddEmployeePresenter presenter = 
            new AddEmployeePresenter(view, 
            transactionContainer, database);

        view.Presenter = presenter;

        LoadView(view);
    }

    private void LoadView(Form view)
    {
        view.Show();
        lastLoadedView = view;
    }
    /// <summary>
    /// 最新的form
    /// </summary>
    public Form LastLoadedView
    {
        get { return lastLoadedView; }
    }
}

public class PayrollMain
{
    public static void Main(string[] args)
    {
        PayrollDatabase database = 
            new InMemoryPayrollDatabase();
        WindowViewLoader viewLoader = 
            new WindowViewLoader(database);
        
        viewLoader.LoadPayrollView();
        Application.Run(viewLoader.LastLoadedView);
    }
}

public class PayrollPresenter
{
    private PayrollView view;
    private readonly PayrollDatabase database;
    private readonly ViewLoader viewLoader;
    private TransactionContainer transactionContainer;

    public PayrollPresenter(PayrollDatabase database,
        ViewLoader viewLoader)
    {
        //this.view = view;
        this.database = database;
        this.viewLoader = viewLoader;
        TransactionContainer.AddAction addAction = 
            new TransactionContainer.AddAction(TransactionAdded);
        transactionContainer = new TransactionContainer(addAction);
    }

    public PayrollView View
    {
        get { return view; }
        set { view = value; }
    }

    public TransactionContainer TransactionContainer
    {
        get { return transactionContainer; }
    }

    public void TransactionAdded()
    {
        UpdateTransactionsTextBox();
    }

    private void UpdateTransactionsTextBox()
    {
        StringBuilder builder = new StringBuilder();
        foreach(Transaction transaction in 
            transactionContainer.Transactions)
        {
            builder.Append(transaction.ToString());
            builder.Append(Environment.NewLine);
        }
        view.TransactionsText = builder.ToString();
    }

    public PayrollDatabase Database
    {
        get { return database; }
    }

    public virtual void AddEmployeeActionInvoked()
    {
        viewLoader.LoadAddEmployeeView(transactionContainer);
    }

    public virtual void RunTransactions()
    {
        foreach(Transaction transaction in 
            transactionContainer.Transactions)
            transaction.Execute();

        transactionContainer.Clear();
        UpdateTransactionsTextBox();
        UpdateEmployeesTextBox();
    }

    private void UpdateEmployeesTextBox()
    {
        StringBuilder builder = new StringBuilder();
        foreach(Employee employee in database.GetAllEmployees())
        {
            builder.Append(employee.ToString());
            builder.Append(Environment.NewLine);
        }
        view.EmployeesText = builder.ToString();
    }
}

public class TransactionContainer
{
    public delegate void AddAction();

    private IList transactions = new ArrayList();
    private AddAction addAction;

    public TransactionContainer(AddAction action)
    {
        addAction = action;
    }

    public IList Transactions
    {
        get { return transactions; }
    }

    public void Add(Transaction transaction)
    {
        transactions.Add(transaction);
        if(addAction != null)
            addAction();
    }

    public void Clear()
    {
        transactions.Clear();
    }
}

public class AddEmployeeWindow : Form, AddEmployeeView
{
    public System.Windows.Forms.TextBox empIdTextBox;
    private System.Windows.Forms.Label empIdLabel;
    private System.Windows.Forms.Label nameLabel;
    public System.Windows.Forms.TextBox nameTextBox;
    private System.Windows.Forms.Label addressLabel;
    public System.Windows.Forms.TextBox addressTextBox;
    public System.Windows.Forms.RadioButton hourlyRadioButton;
    public System.Windows.Forms.RadioButton salaryRadioButton;
    public System.Windows.Forms.RadioButton commissionRadioButton;
    private System.Windows.Forms.Label hourlyRateLabel;
    public System.Windows.Forms.TextBox hourlyRateTextBox;
    private System.Windows.Forms.Label salaryLabel;
    public System.Windows.Forms.TextBox salaryTextBox;
    private System.Windows.Forms.Label commissionSalaryLabel;
    public System.Windows.Forms.TextBox commissionSalaryTextBox;
    private System.Windows.Forms.Label commissionLabel;
    public System.Windows.Forms.TextBox commissionTextBox;
    private System.Windows.Forms.TextBox textBox2;
    private System.Windows.Forms.Label label1;
    private System.ComponentModel.Container components = null;
    public System.Windows.Forms.Button submitButton;
    private AddEmployeePresenter presenter;

    public AddEmployeeWindow()
    {
        InitializeComponent();
    }

    protected override void Dispose( bool disposing )
    {
        if( disposing )
        {
            if(components != null)
            {
                components.Dispose();
            }
        }
        base.Dispose( disposing );
    }
    public AddEmployeePresenter Presenter
    {
        get { return presenter; }
        set { presenter = value; }
    }

    private void hourlyRadioButton_CheckedChanged(
        object sender, System.EventArgs e)
    {
        hourlyRateTextBox.Enabled = hourlyRadioButton.Checked;
        presenter.IsHourly = hourlyRadioButton.Checked;
    }

    private void salaryRadioButton_CheckedChanged(
        object sender, System.EventArgs e)
    {
        salaryTextBox.Enabled = salaryRadioButton.Checked;
        presenter.IsSalary = salaryRadioButton.Checked;
    }

    private void commissionRadioButton_CheckedChanged(
        object sender, System.EventArgs e)
    {
        commissionSalaryTextBox.Enabled = 
            commissionRadioButton.Checked;
        commissionTextBox.Enabled = 
            commissionRadioButton.Checked;
        presenter.IsCommission = 
            commissionRadioButton.Checked;
    }

    private void empIdTextBox_TextChanged(
        object sender, System.EventArgs e)
    {
        presenter.EmpId = AsInt(empIdTextBox.Text);
    }

    private void nameTextBox_TextChanged(
        object sender, System.EventArgs e)
    {
        presenter.Name = nameTextBox.Text;
    }

    private void addressTextBox_TextChanged(
        object sender, System.EventArgs e)
    {
        presenter.Address = addressTextBox.Text;
    }

    private void hourlyRateTextBox_TextChanged(
        object sender, System.EventArgs e)
    {
        presenter.HourlyRate = AsDouble(hourlyRateTextBox.Text);
    }

    private void salaryTextBox_TextChanged(
        object sender, System.EventArgs e)
    {
        presenter.Salary = AsDouble(salaryTextBox.Text);
    }

    private void commissionSalaryTextBox_TextChanged(
        object sender, System.EventArgs e)
    {
        presenter.CommissionSalary = 
            AsDouble(commissionSalaryTextBox.Text);
    }

    private void commissionTextBox_TextChanged(
        object sender, System.EventArgs e)
    {
        presenter.Commission = AsDouble(commissionTextBox.Text);
    }

    private void addEmployeeButton_Click(
        object sender, System.EventArgs e)
    {
        presenter.AddEmployee();
        this.Close();
    }

    private double AsDouble(string text)
    {
        try
        {
            return Double.Parse(text);
        }
        catch (Exception)
        {
            return 0.0;
        }
    }

    private int AsInt(string text)
    {
        try
        {
            return Int32.Parse(text);
        }
        catch (Exception)
        {
            return 0;
        }
    }

    public bool SubmitEnabled
    {
        set { submitButton.Enabled = value; }
    }
}

完毕