改变类的依赖

      我们经常需要对一段已有的代码进行修改，结果是一处小的变动就会在整个应用程序中产生连锁反应，导致无法编译通过，甚至能引入某种错误。然而，软件总是需要经常的改变，代码具有弹性、灵活性和适应性，并最终让软件更加具有可维护性是很重要的。不容易改变最大的阻力来自于依赖。

一、评估代码的依赖程度                                                                                                 
      面向对象程序设计的真正威力在于，对象相互之间能够进行交互，从而形成一个更复杂的模块或组件。这样，我们就能执行更加复杂的过程，这个过程能够转化为通过工作流解决业务问题。依赖就是对象需要用户正确发挥功能的东西；识别代码中的依赖的一种容易的方式就是找出创建其他类的新实例的地方。通过在一个类中创建另一个类的实例，马上就建立了依赖，并使代码成为紧密耦合代码。了解这一点最好的方式当然就是示例：
   假定您正供职于一家提供电子商务方案的软件公司。当前的程序只需要支持使用Alipay（支付宝）支付商提取订单付款和执行退款业务。
然而，有些客户需要使用ChinaPay支付平台。您的老板同意在下一个发布版本中包含这个新的支付平台，并选择允许公司通过一种配置设置来指定支付平台。

(1)我们新建一个类库项目并在项目中添加三个文件夹Model、Properties、Services。
(2)在Model文件夹中添加一个Customer类，表示退回订单项的消费者

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ProEnt.Chap3.Returns.Model
{
    public class Customer
    {
        private string _emailAddress;
        private string _name;
        private string _mobileNumber;

        public string EmailAddress
        {
            get { return _emailAddress; }
            set { _emailAddress = value; }
        }

        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        public string MobileNumber
        {
            get { return _mobileNumber; }
            set { _emailAddress = value; }
        } 
    }
}

（3）在Model文件夹下，添加Product，表示消费者退订的产品

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ProEnt.Chap3.Returns.Model
{
    public class Product
    {
        private int _id;
        private int _stock;
        private string _name;

        public int Id 
        { 
            get { return _id; }
            set { _id = value; }
        }

        public int Stock
        {
            get { return _stock;}
            set { _stock = value;}
        }

        public string Name
        {
            get { return _name;}
            set { _name = value; }
        }
    }
}

（4）在Model文件夹下，添加ReturnItem，表示消费者退订的项：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ProEnt.Chap3.Returns.Model
{
    public class ReturnItem
    {
        private int _qty;
        private Product _product;
        private decimal _unitPricePaid;

        public int Qty
        {
            get { return _qty;}
            set { _qty = value; }
        }

        public Product Product 
        { 
            get { return _product;}
            set { _product = value;}
        }

        public decimal UnitPricePaid
        {
            get { return _unitPricePaid; }
            set { _unitPricePaid = value; }
        }

        public decimal LinePrice()
        {
            return UnitPricePaid * Qty;
        }
    }
}

（5）在Model文件夹下，添加ReturnOrder，表示消费者退订的项：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ProEnt.Chap3.Returns.Model
{
    public class ReturnOrder
    {
        private Customer _customer;
        private IList<ReturnItem> _itemsToReturn;
        private string _paymentTransactionId;

        public string PaymentTransactionId
        {
            get { return _paymentTransactionId; }
            set { _paymentTransactionId = value; }
        }

        public Customer Customer
        {
            get { return _customer; }
            set { _customer = value; }
        }

        public IList<ReturnItem> ItemsToReturn
        {
            get { return _itemsToReturn; }
            set { _itemsToReturn = value; }
        }

        public void MarkAsProcessed()
        {
            // Changes the state of the order
        }

        public decimal RefundTotal()
        {
            var query = from Item in ItemsToReturn
                        select Item;

            return query.Sum(a => a.LinePrice());
        }
    }
}

（6）为了能够保存对象，并从数据存储中检索该对象，需要添加Product对象和ReturnOrder库。添加一个新类到Properties文件夹中，命名为：ProductRepository。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ProEnt.Chap3.Returns.Model;

namespace ProEnt.Chap3.Returns.Repositories
{    
    public class ProductRepository 
    {
        public Product FindBy(long Id)
        {            
            // Here you would find code to 
            // retrieve Product from the data store.
            return null;
        }

        public void Save(Product product)
        {
            // Here you would find code to persist 
            // Product to the data store.            
        }
    }
}

（7）同样添加一个名为ReturnOrderRepository的类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ProEnt.Chap3.Returns.Model;

namespace ProEnt.Chap3.Returns.Repositories
{    
    public class ReturnOrderRepository 
    {
        public void Save(ReturnOrder ReturnOrder)
        {
            // Here you would find code to persist 
            // a ReturnOrder to the data store.
        }
    }
}

（8）为了Alipay能退款，需要一个AlipayGateway网关。在Services文件夹中添加一个名叫AlipayGateway的类：

using System;

namespace ProEnt.Chap3.Returns.Services
{   
    public class AlipayGateway 
    {

        public AlipayGateway(string userName, string password)
        {
            // Here you would find code to login to the 
            // PayPal payment merchant.
        }

        public Boolean Refund(decimal amount, string transactionId)
        {
            // Here you would find code to create a refund
            // transaction and send it to PayPal.
            return true;
        }    
    }
}

（9）最后还要添加一个ReturnOrderService类到Services文件夹中。该类负责调整退订项的库存、将钱退回给相应的消费者，以及通知消费者退单过程已经完成。

using System;
using System.Net.Mail;
using System.Text;
using ProEnt.Chap3.Returns.Repositories;
using ProEnt.Chap3.Returns.Model;

namespace ProEnt.Chap3.Returns.Services
{
    public class ReturnOrderService
    {
        private ProductRepository _productRepository;
        private ReturnOrderRepository _returnOrderRepository;
        private AlipayGateway _alipayGateway;

        //这些最好从配置文件中读取，在这里为了示例简单就设置为空
        private string _alipayUserName = string.Empty;
        private string _alipayPassword = string.Empty;
        private string _smtpHost = string.Empty;

        public ReturnOrderService() {
            _productRepository = new ProductRepository();
            _returnOrderRepository = new ReturnOrderRepository();
            _alipayGateway = new AlipayGateway(_alipayUserName, _alipayPassword);
        }

        public void Process(ReturnOrder returnOrder) { 
           // 1)Update the stock(库存)
            foreach (ReturnItem item in returnOrder.ItemsToReturn) {
                // a）Find the product
                Product product = _productRepository.FindBy(item.Product.Id);
                // b）Increase(增加) the stock
                product.Stock += item.Qty;
                // c) Save the product
                _productRepository.Save(product);

            }

            // 2）Refund the payment back to the customer
            _alipayGateway.Refund(returnOrder.RefundTotal(), returnOrder.PaymentTransactionId);
            
            // 3) Mark the return order as processed
            returnOrder.MarkAsProcessed();

            // 4) Save the updated return order
            _returnOrderRepository.Save(returnOrder);

            // 5) Notify the customer on the processing of the return.
            String recipient = returnOrder.Customer.EmailAddress;
            string from = "Returns@MyCompany.com";
            String subject = "Your return order has been processed.";
            StringBuilder message = new StringBuilder();
            message.AppendLine(string.Format("Hello {0}",returnOrder.Customer.Name));
            message.AppendLine(" You return order has been processed and you have been refunded.");
            message.AppendLine("Items returned: ");
            foreach (ReturnItem itemReturning in returnOrder.ItemsToReturn) {
                message.AppendLine(string.Format("{0} of {1}",itemReturning.Qty,itemReturning.Product.Name));
            }
            message.AppendLine("Regards");
            message.AppendLine("Returns Department");

            MailMessage msgMail = new MailMessage(from,recipient,subject,message.ToString());
            SmtpClient smtp = new SmtpClient(_smtpHost);
            smtp.Send(msgMail);
        }
    }
}

       只有我们理解了ReturnOrderService内部机制，才能添加代码来支持ChinaPay支付平台。有人可能认为，添加ChinaPay支付平台最简单的方式是添加一个新的支付网关ChinaPayGateway。退款给Alipay方式一样，在ReturnOrderService中使用ChinaPayGateway。
我们首先在Services文件夹中创建一个新类ChinaPayGateway：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ProEnt.Chap3.Returns.Services
{
    public class ChinaPayGateway 
    {
        public ChinaPayGateway(string MerchantAccount, string userName, string password)
        {
            // Here you would find code to login to the 
            // WorldPay payment merchant.
        }
      
        public Boolean Refund(decimal amount, string transactionId)
        {
           // Here you would find code to create a refund
            // transaction and send it to the WorldPay payment merchant.    
            return true;
        }    
    }
}

现在可以按照下面的方式修改ReturnOrderService

using System;
using System.Net.Mail;
using System.Text;
using ProEnt.Chap3.Returns.Repositories;
using ProEnt.Chap3.Returns.Model;

namespace ProEnt.Chap3.Returns.Services
{
    public class ReturnOrderService
    {
        private ProductRepository _productRepository;
        private ReturnOrderRepository _returnOrderRepository;
        private AlipayGateway _alipayGateway;


        private ChinaPayGateway _chinaPayGateway;


        //这些最好从配置文件中读取，在这里为了示例简单就设置为空
        private string _alipayUserName = string.Empty;
        private string _alipayPassword = string.Empty;
        private string _smtpHost = string.Empty;

        private string _chinaPayUserName = string.Empty;
        private string _chinaPayPassword = string.Empty;
        private string _chinaPayMerchantId = string.Empty;
        private string _paymentGatewayType = string.Empty;

        public ReturnOrderService() {
            _productRepository = new ProductRepository();
            _returnOrderRepository = new ReturnOrderRepository();

            if (_paymentGatewayType == "Alipay")
            {
                _alipayGateway = new AlipayGateway(_alipayUserName, _alipayPassword);
            }
            else if (_paymentGatewayType == "ChinaPay")
            {
                _chinaPayGateway = new ChinaPayGateway(_chinaPayMerchantId, _chinaPayUserName, _chinaPayPassword);
            }
         
        }

        public void Process(ReturnOrder returnOrder) { 
           // 1)Update the stock(库存)
            foreach (ReturnItem item in returnOrder.ItemsToReturn) {
                // a）Find the product
                Product product = _productRepository.FindBy(item.Product.Id);
                // b）Increase(增加) the stock
                product.Stock += item.Qty;
                // c) Save the product
                _productRepository.Save(product);

            }

            // 2）Refund the payment back to the customer
            if (_paymentGatewayType == "Alipay")
            {
                _alipayGateway.Refund(returnOrder.RefundTotal(), returnOrder.PaymentTransactionId);
            }
            else if (_paymentGatewayType == "ChinaPay") {
                _chinaPayGateway.Refund(returnOrder.RefundTotal(), returnOrder.PaymentTransactionId);
            }


            // 3) Mark the return order as processed
            returnOrder.MarkAsProcessed();

            // 4) Save the updated return order
            _returnOrderRepository.Save(returnOrder);

            // 5) Notify the customer on the processing of the return.
            String recipient = returnOrder.Customer.EmailAddress;
            string from = "Returns@MyCompany.com";
            String subject = "Your return order has been processed.";
            StringBuilder message = new StringBuilder();
            message.AppendLine(string.Format("Hello {0}",returnOrder.Customer.Name));
            message.AppendLine(" You return order has been processed and you have been refunded.");
            message.AppendLine("Items returned: ");
            foreach (ReturnItem itemReturning in returnOrder.ItemsToReturn) {
                message.AppendLine(string.Format("{0} of {1}",itemReturning.Qty,itemReturning.Product.Name));
            }
            message.AppendLine("Regards");
            message.AppendLine("Returns Department");

            MailMessage msgMail = new MailMessage(from,recipient,subject,message.ToString());
            SmtpClient smtp = new SmtpClient(_smtpHost);
            smtp.Send(msgMail);
        }
    }
}

      因为时间紧迫，所以添加ChinaPay支付选项时，使用过程编码模式与前任开发人员一样；这看起来好像是最容易和最快的解决方案。
在对ReturnOrderService类进行回顾后，发现该类与很多类是紧密耦合的。这样的设计是比较差的。

刚性

上面列出的代码刚性如何呢？为了改变低层关注点的任何方面，例如AlipayGateway的构建方式，需要修改高层类（ReturnOrderService）。这 表明该类是不灵活的，难以改变的。

灵活性

灵活性测度的是改变代码的难易程度。以ReturnOrderService为例，如果该类型多依赖的类型进行了任何的改变，那么很可能破坏原有结果。 相对较低层的改变会影响到高层模块。

关注点分离

ReturnOrderService的关注点 显然没有得到分离，因为它应该只与负责处理退货订单工作流程相关，而不应受限于其他的细节。

可重用性

重用性测度是代码的可移植性，以及在软件其他地方可以重用到什么程度。显然其他类中也不能使用该过程中的部分代码。重用发送电子邮件的逻辑，处理库存调整的代码，我们都应该与其他地方重用。

可维护性

方法应该短而精：在命名上，这些方法应该能够直接体现出它们所要完成的功能。ReturnOrderService类当前的实现非常的不可读，需要一定的时间 来完全理解，在修改和添加功能后，变的更不好读。由于具有紧密耦合的相关性，导致代码缺乏清晰性。当添加功能是，对自己和别人来讲，维护代码库 都将是困难的。还可以看出ReturnOrderService并不符合单一职责准则，该类关注过多的底层细节。 并不是添加新的支付商才导致该类表现出脆弱性，而是实现任意类似的功能时都可能导致问题

1. AlipayGateway包装器实现可能改变
2. 退货入库过程可能要求将所有的库存调整记录在一个aduit表中。
3. 改变配置设置

该代码块存在的另一个问题就是测试。单元测试的目的是要将程序的各个部分分离，并校验每个单独部分的行为是否如期望的那样。这里只能做集成测试了。

二、关注点分离和识别模块性

     既然知道这段代码存在问题，我们现在就开始重构这段代码。  首先，需要分离ReturnOrderService类中出现的每个关注点。

     关注点分离准则：就是对软件短进行分解，并将其分割为独立的功能，这些功能封装了其他类可能使用的不同行为和数据。  通过模块化代码，并封装不同的特定数据和行为 就可以达到关注点分离的目的。

     首先我们来看一下第一段代码，这段代码负责将商品返回库存清单。我们可以封装调整库存的过程，并将这个关注点与退货订单工作流程分离。  我们新添加一个ProductService类，提供调整库存的产品列表相关的服务。

using ProEnt.Chap3.Returns.Repositories;
using ProEnt.Chap3.Returns.Model;

namespace ProEnt.Chap3.Returns.Services
{
    public class ProductService 
    {

        private ProductRepository _productRepository; 
        public ProductService()
        {
            _productRepository = new ProductRepository();
        }

        public void ReturnStockFor(ReturnOrder ReturnOrder)
        {
            // 1) Update the stock.                      
            foreach (ReturnItem Item in ReturnOrder.ItemsToReturn)
            {
                // a) Find the product.
                Product product = _productRepository.FindBy(Item.Product.Id);
                // b) Increase the stock.
                product.Stock += Item.Qty;
                // c) Save the product.
                _productRepository.Save(product);
            }
        }
    }
}

回到ReturnOrderService类，删除对ProductRepository类的引用，并且使用新类ProductService的调用替代他们。变更可存的代码变的如下：

// 1)Update the stock(库存)
  _productService.ReturnStockFor(returnOrder);

　　

     需要处理的下一段代码就是关于电子邮件的逻辑。首先提取创建消息体的代码段放到一个新方法中，并命名为BuildReturnMessageFrom。 接下来，将发送邮件的方法提取到一个新方法中，并命名为SendReturnOrderNotifiationFor。已经提取两个电子邮件方法，现在创建一个新类将通知的动作与退单的工作流程分离。在Services文件夹中创建一个新的服务，将其命名为EmailNotificationService。

using System;
using System.Net.Mail;
using System.Text;
using ProEnt.Chap3.Returns.Model;

namespace ProEnt.Chap3.Returns.Services
{
    public class EmailNotificationService 
    {
        // This settings would be stored in the AppSettings of the config file.
        private string _smtpHost = string.Empty;

        public void SendReturnOrderNotificationFor(ReturnOrder ReturnOrder)
        {
            // 5) Notify the customer on the processing of the return.
            String Recipient = ReturnOrder.Customer.EmailAddress;
            String From = "Returns@MyCompany.com";
            String Subject = "Your return order has been processed.";
            StringBuilder Message = BuildReturnMessageFrom(ReturnOrder);

            MailMessage msgMail = new MailMessage(From, Recipient, Subject, Message.ToString());

            SmtpClient smtp = new SmtpClient(_smtpHost);
            smtp.Send(msgMail);
        }

        private StringBuilder BuildReturnMessageFrom(ReturnOrder ReturnOrder)
        {
            StringBuilder Message = new StringBuilder();

            Message.AppendLine(String.Format("Hello {0}", ReturnOrder.Customer.Name));
            Message.AppendLine("You return order has been processed and you have been refunded.");

            Message.AppendLine("Items returned: ");
            foreach (ReturnItem ItemReturning in ReturnOrder.ItemsToReturn)
            {
                Message.AppendLine(String.Format("{0} of {1}", ItemReturning.Qty, ItemReturning.Product.Name));
            }

            Message.AppendLine("Regards");
            Message.AppendLine("Returns Department");
            return Message;
        }  
    }
}

现在通过对新类EmailNotificationService的引用，就可以更新ReturnOrderService类。

using System;
using System.Net.Mail;
using System.Text;
using ProEnt.Chap3.Returns.Repositories;
using ProEnt.Chap3.Returns.Model;

namespace ProEnt.Chap3.Returns.Services
{
    public class ReturnOrderService
    {
        private EmailNotificationService _notificationService;
        private ProductService _productService;
        private ReturnOrderRepository _returnOrderRepository;
        private AlipayGateway _alipayGateway;
        private ChinaPayGateway _chinaPayGateway;

        //这些最好从配置文件中读取，在这里为了示例简单就设置为空
        private string _alipayUserName = string.Empty;
        private string _alipayPassword = string.Empty;
        private string _smtpHost = string.Empty;

        private string _chinaPayUserName = string.Empty;
        private string _chinaPayPassword = string.Empty;
        private string _chinaPayMerchantId = string.Empty;
        private string _paymentGatewayType = string.Empty;

        public ReturnOrderService() {
            _notificationService = new EmailNotificationService();
            _productService = new ProductService();
            _returnOrderRepository = new ReturnOrderRepository();
            if (_paymentGatewayType == "Alipay")
            {
                _alipayGateway = new AlipayGateway(_alipayUserName, _alipayPassword);
            }
            else if (_paymentGatewayType == "ChinaPay")
            {
                _chinaPayGateway = new ChinaPayGateway(_chinaPayMerchantId, _chinaPayUserName, _chinaPayPassword);
            }
         
        }

        public void Process(ReturnOrder returnOrder) { 
           // 1)Update the stock(库存)
            _productService.ReturnStockFor(returnOrder);

            // 2）Refund the payment back to the customer
            if (_paymentGatewayType == "Alipay")
            {
                _alipayGateway.Refund(returnOrder.RefundTotal(), returnOrder.PaymentTransactionId);
            }
            else if (_paymentGatewayType == "ChinaPay") {
                _chinaPayGateway.Refund(returnOrder.RefundTotal(), returnOrder.PaymentTransactionId);
            }
            // 3) Mark the return order as processed
            returnOrder.MarkAsProcessed();

            // 4) Save the updated return order
            _returnOrderRepository.Save(returnOrder);

            // 5) Notify the customer on the processing of the return.
            _notificationService.SendReturnOrderNotificationFor(returnOrder);
        }
    }
}

      对于最后一个重构器，需要提取处理支付方法的逻辑。两种支付网关的退货方法，都需要TransactionId和Amount来处理退货。可以提取一个超类，让两种支付网关的情况通过继承实现；第一步构建一个基类，使AlipayGateway和ChinaPayGateway都继承它。在service文件夹中添加一个名为PaymentGateway的新类：

using System;

namespace ProEnt.Chap3.Returns.Services
{
    public abstract class PaymentGateway 
    {
        public abstract Boolean Refund(decimal amount, string transactionId);
    }
}

　　之后，我们要调整AlipayGateway和ChinaPayGateway，使他们继承已经创建好的基类：

  public class AlipayGateway :PaymentGateway
    {

        public AlipayGateway(string userName, string password)
        {
            // Here you would find code to login to the 
            // PayPal payment merchant.
        }

        public override Boolean Refund(decimal amount, string transactionId)
        {
            // Here you would find code to create a refund
            // transaction and send it to PayPal.
            return true;
        }    
    }


     public class ChinaPayGateway :PaymentGateway
    {
        public ChinaPayGateway(string MerchantAccount, string userName, string password)
        {
            // Here you would find code to login to the 
            // WorldPay payment merchant.
        }
      
        public override Boolean Refund(decimal amount, string transactionId)
        {
           // Here you would find code to create a refund
            // transaction and send it to the WorldPay payment merchant.    
            return true;
        }    
    }

     现在ReturnOrderService类可以在Process()方法中使用新的PaymentGateway抽象基类执行退货，并将确定使用哪种支付平台实现的问题留在构造函数中完成：

using System;
using System.Net.Mail;
using System.Text;
using ProEnt.Chap3.Returns.Repositories;
using ProEnt.Chap3.Returns.Model;

namespace ProEnt.Chap3.Returns.Services
{
    public class ReturnOrderService
    {
        private EmailNotificationService _notificationService;
        private ProductService _productService;
        private ReturnOrderRepository _returnOrderRepository;
        private PaymentGateway _paymentGateway;


        //这些最好从配置文件中读取，在这里为了示例简单就设置为空
        private string _alipayUserName = string.Empty;
        private string _alipayPassword = string.Empty;
        private string _smtpHost = string.Empty;

        private string _chinaPayUserName = string.Empty;
        private string _chinaPayPassword = string.Empty;
        private string _chinaPayMerchantId = string.Empty;
        private string _paymentGatewayType = string.Empty;

        public ReturnOrderService() {
            _notificationService = new EmailNotificationService();
            _productService = new ProductService();
            _returnOrderRepository = new ReturnOrderRepository();
            if (_paymentGatewayType == "Alipay")
            {
                _paymentGateway = new AlipayGateway(_alipayUserName, _alipayPassword);
            }
            else if (_paymentGatewayType == "ChinaPay")
            {
                _paymentGateway = new ChinaPayGateway(_chinaPayMerchantId, _chinaPayUserName, _chinaPayPassword);
            }
         
        }

        public void Process(ReturnOrder returnOrder) { 
         
            _productService.ReturnStockFor(returnOrder);

            _paymentGateway.Refund(returnOrder.RefundTotal(), returnOrder.PaymentTransactionId);

            returnOrder.MarkAsProcessed();

            _returnOrderRepository.Save(returnOrder);

            _notificationService.SendReturnOrderNotificationFor(returnOrder);
        }
    }
}

三、依赖倒置准则

       我们对代码进行模块化处理，并将单一职责和关注点分离准则应用到ReturnOrderService后，其对较低层模块的依赖依然没有变。 需要一种方式消除这种具体的依赖，使得对低层模块的改变不会影响到ReturnOrderService。应该将这种状况倒置过来， 有些人将倒置以后的情形称为“好莱坞准则”：“不用给我们打电话，我们会给你打电话”。这意味着要以抽象的形式来引用低层 模块，而不是引用具体的实现。    

依赖倒置准则定义：  

（1）高层模块不应该依赖于低层模块。两者都应该依赖于抽象。  

（2）抽象不应该依赖于细节。细节应该依赖于抽象。    

      依赖倒置准则就是将类从具体的实现中分离出来，让这些类仅依赖于抽象类或接口。当使用了依赖倒置准则以后，对低层模块的改变不再会 对高层模块产生想前面列出的代码中所见到的影响了。

    应用依赖倒置准的第一步是针对每种低层依赖提取接口。首先，可以针对ProjuctService提取接口。打开ProjuctService类，然后右击显示上下文菜单， 从中选择 重构|提取接口命令。在弹出对话框中单击“选择全部”按钮，然后单击“确定”按钮。 现在我们有了针对ProjuctService的接口，因此可以将其用于ReturnOrderService类。  对下面的类，执行同样的提取接口重构，并将具体的变量声明替换为使用接口进行的声明。

1.  EmailNotificationService 将接口命名为 INotificationService。  
2.  ReturnOrderRepository 将接口命名为 IReturnOrderRepository。
3.  ProductRepository 将接口命名为 IProductRepository。  
4.  PaymentGateway 将接口命名为 IPaymentGateway。

 完成这些工作后，ReturnOrderService类如下所示：

using System;
using System.Net.Mail;
using System.Text;
using ProEnt.Chap3.Returns.Repositories;
using ProEnt.Chap3.Returns.Model;

namespace ProEnt.Chap3.Returns.Services
{
    public class ReturnOrderService
    {
        private INotificationService _notificationService;
        private IProductService _productService;
        private IReturnOrderRepository _returnOrderRepository;
        private IPaymentGateway _paymentGateway;


        //这些最好从配置文件中读取，在这里为了示例简单就设置为空
        private string _alipayUserName = string.Empty;
        private string _alipayPassword = string.Empty;
        private string _smtpHost = string.Empty;

        private string _chinaPayUserName = string.Empty;
        private string _chinaPayPassword = string.Empty;
        private string _chinaPayMerchantId = string.Empty;
        private string _paymentGatewayType = string.Empty;

        public ReturnOrderService() {
            _notificationService = new EmailNotificationService();
            _productService = new ProductService();
            _returnOrderRepository = new ReturnOrderRepository();
            if (_paymentGatewayType == "Alipay")
            {
                _paymentGateway = new AlipayGateway(_alipayUserName, _alipayPassword);
            }
            else if (_paymentGatewayType == "ChinaPay")
            {
                _paymentGateway = new ChinaPayGateway(_chinaPayMerchantId, _chinaPayUserName, _chinaPayPassword);
            }
         
        }

        public void Process(ReturnOrder returnOrder) { 
           // 1)Update the stock(库存)
            _productService.ReturnStockFor(returnOrder);

            // 2）Refund the payment back to the customer
            _paymentGateway.Refund(returnOrder.RefundTotal(), returnOrder.PaymentTransactionId);

            // 3) Mark the return order as processed
            returnOrder.MarkAsProcessed();

            // 4) Save the updated return order
            _returnOrderRepository.Save(returnOrder);

            // 5) Notify the customer on the processing of the return.
            _notificationService.SendReturnOrderNotificationFor(returnOrder);
        }
    }
}

现在ReturnOrderService类依赖于接口形式的抽象类，而不是直接依赖于具体的实现。

四、使用依赖注入彻底解放类

       ReturnOrderService类依然与每个接口的单一实现关联，它仍然负责创建那些依赖关系；例如如果希望使用不同类型的INotificationService，那么就必须 修改ReturnOrderService类，这可能需要添加更多的一些配置项。这显然不合适，我们可以用依赖注入来帮助我们解决这个问题。

      依赖注入模式是指为高层模块提供外部依赖行为。它属于一种控制倒置，在该方法中，获取低层模块的过程是倒置的关注点。 控制倒置通常与依赖注入互换使用，它是一种高层抽象准则，与工作流的过程样式相比，控制倒置与系统的流或过程的倒置有关；

     使用依赖注入获得对外部模块引用，方法有三种：

• 构造函数注入：构造函数注入通常应用于重构的最后阶段，它是通过类的构造函数提供依赖的过程。
• 设置函数注入：设置函数注入通过设置函数（setter）属性将依赖模块注入依赖模块的过程。
• 方法注入：方法注入要求依赖实现一个接口，高层模块会在运行时引用和注入这个接口。

     现在将依赖注入的构造函数注入应用于ReturnOrderService，从而将INotificationService的实例注入Service类，而不再在构造函数中创建。 修改过ReturnOrderService类代码如下所示：

public ReturnOrderService(INotificationService notificationService)
  {
            _notificationService = notificationService;
			.....
  }

　　现在ReturnOrderService类不再负责创建NotificationService类的有效实例了，更重要的是，service类不再与INotificationService的任何一个实现相关；

     设置函数注入需要使用关于高层模块的属性以注入低层模块的依赖。这样的好处之一就是允许随意的交换依赖。这种方式提供了更大的灵活性。对于一个更复杂的示例，不使用构造函数，而是通过一个设置函数（setter）属性，就可以在ReturnOrderService中添加一个属性注入INotificationService的实例。如果不打算向消费者发送退单通知，那么可以选择不注入INotificationService的实例，或者使用一个占位程序实现。实现代码如下所示：

using System;
using System.Net.Mail;
using System.Text;
using ProEnt.Chap3.Returns.Repositories;
using ProEnt.Chap3.Returns.Model;

namespace ProEnt.Chap3.Returns.Services
{
    public class ReturnOrderService
    {
        private INotificationService _notificationService;
        private IProductService _productService;
        private IReturnOrderRepository _returnOrderRepository;
        private IPaymentGateway _paymentGateway;


        //这些最好从配置文件中读取，在这里为了示例简单就设置为空
        private string _alipayUserName = string.Empty;
        private string _alipayPassword = string.Empty;
        private string _smtpHost = string.Empty;

        private string _chinaPayUserName = string.Empty;
        private string _chinaPayPassword = string.Empty;
        private string _chinaPayMerchantId = string.Empty;
        private string _paymentGatewayType = string.Empty;

        public ReturnOrderService()
        {
            _productService = new ProductService();
            _returnOrderRepository = new ReturnOrderRepository();
            if (_paymentGatewayType == "Alipay")
            {
                _paymentGateway = new AlipayGateway(_alipayUserName, _alipayPassword);
            }
            else if (_paymentGatewayType == "ChinaPay")
            {
                _paymentGateway = new ChinaPayGateway(_chinaPayMerchantId, _chinaPayUserName, _chinaPayPassword);
            }
         
        }

        public void Process(ReturnOrder returnOrder) { 
           // 1)Update the stock(库存)
            _productService.ReturnStockFor(returnOrder);

            // 2）Refund the payment back to the customer
            _paymentGateway.Refund(returnOrder.RefundTotal(), returnOrder.PaymentTransactionId);

            // 3) Mark the return order as processed
            returnOrder.MarkAsProcessed();

            // 4) Save the updated return order
            _returnOrderRepository.Save(returnOrder);

            if (_notificationService != null) {
                _notificationService.SendReturnOrderNotificationFor(returnOrder);
            }
        }
        public INotificationService NotificationService {
            get { return _notificationService; }
            set { _notificationService = value; }
        }
    }
}

      需要注意的是，设置函数注入仅有的不足是，需要进行一定的检查以确保在使用依赖之前已经设置了该依赖。设置函数注入方法可能不如构造函数注入那么显而易见，但是如果在构造函数中需要注入大量的其他依赖，那么将可选的依赖移到基于设置函数的方法更加明智。

     使用方法注入的一个适当场合是当需要有一些不适合放入属性的逻辑时。当需要将日志 功能添加到ReturnOrderService和所有的低层依赖中时，可以在ReturnOrderService中添加一个方法，然后该类会自动更新所有与该日志相关的依赖。示例代码如下所示：

 public class ReturnOrderService
    {
        ...

        public ReturnOrderService()
        {
           ...
         
        }

        public void Process(ReturnOrder returnOrder) { 
           ...
        }
      
        public void SetLogger(ILogger logger) { 
           _notificationService.SetLogger(logger);
           _productService.SetLogger(logger);
           _returnOrderRepository.SetLogger(logger);
           _paymentGateway.SetLogger(logger);
        }
    }

　　为了在创建所有的依赖时确保这些依赖都注入到了ReturnOrderService中，可以选择依赖注入的构造函数注入。从ProductService类开始，按照如下方式修改构造函数：

using ProEnt.Chap3.Returns.Repositories;
using ProEnt.Chap3.Returns.Model;

namespace ProEnt.Chap3.Returns.Services
{
    public class ProductService : ProEnt.Chap3.Returns.Services.IProductService 
    {

        private ProductRepository _productRepository;
        public ProductService(ProductRepository productRepository)
        {
            _productRepository = productRepository;
        }

        public void ReturnStockFor(ReturnOrder ReturnOrder)
        {
            // 1) Update the stock.                      
            foreach (ReturnItem Item in ReturnOrder.ItemsToReturn)
            {
                // a) Find the product.
                Product product = _productRepository.FindBy(Item.Product.Id);
                // b) Increase the stock.
                product.Stock += Item.Qty;
                // c) Save the product.
                _productRepository.Save(product);
            }
        }
    }
}

     接下来，修改ReturnOrderService类的构造函数：

using System;
using System.Net.Mail;
using System.Text;
using ProEnt.Chap3.Returns.Repositories;
using ProEnt.Chap3.Returns.Model;

namespace ProEnt.Chap3.Returns.Services
{
    public class ReturnOrderService
    {
        private INotificationService _notificationService;
        private IProductService _productService;
        private IReturnOrderRepository _returnOrderRepository;
        private IPaymentGateway _paymentGateway;

        public ReturnOrderService(INotificationService notificationService, IProductService productService, IReturnOrderRepository returnOrderRepository, IPaymentGateway paymentGateway)
        {
            _notificationService = notificationService;
            _productService = productService;
            _returnOrderRepository = returnOrderRepository;
            _paymentGateway = paymentGateway;
        }

        public void Process(ReturnOrder returnOrder) { 
           // 1)Update the stock(库存)
            _productService.ReturnStockFor(returnOrder);

            // 2）Refund the payment back to the customer
            _paymentGateway.Refund(returnOrder.RefundTotal(), returnOrder.PaymentTransactionId);

            // 3) Mark the return order as processed
            returnOrder.MarkAsProcessed();

            // 4) Save the updated return order
            _returnOrderRepository.Save(returnOrder);

            if (_notificationService != null) {
                _notificationService.SendReturnOrderNotificationFor(returnOrder);
            }
        }
       
    }
}

可以看出，依赖注入是高层依赖倒置准则的一种实现，以及依赖注入本身就是某种形式的控制反转。

刚性

现在ReturnOrderService很容易改变依赖，而不用担心影响到ReturnOrderService本身。

灵活性

现在不存在由于低层细节改变而导致ReturnOrderService类崩溃的危险；这是因为ReturnOrderService依赖于接口而不依赖于具体的类型。

关注点分离

现在，退单返还相关的每个过程的关注点都位于独立的类中，而这些类都是通过接口来引用的，ReturnOrderService仅负责协调工作流，不再处理低层细节；

可重性

现在，对于低层模块的任意数量的新实现，ReturnOrderService都可以得到重用，而自身却不会发生改变

可维护性

现在ReturnOrderService职责很清晰，并通过显而易见的服务名和方法名，从而使开发人员和以后的维护人员，快速的浏览高层过程方法。

从客户的观点来看如何使用ReturnOrderService类的代码如下：

            ReturnOrderService returnOrderService;
            INotificationService notificationService = new EmailNotificationService();
            IProductRepository productRepository = new ProductRepository();
            IProductService productService = new ProductService(productRepository);

            IPaymentGateway paymentGateway = new AlipayGateway("USERNAME","PASSWORD");
            IReturnOrderRepository returnOrderRepository = new ReturnOrderRepository();

            returnOrderService = new ReturnOrderService(notificationService, productService, returnOrderRepository, paymentGateway);