前言
“艺术源于生活”——代码也源于生活，你在生活中的一些行为习惯，可能会恰如其分地体现在代码中。
当实现较为复杂的功能时，由于它包含一系列的逻辑，我们倾向于编写一个“大方法”来实现。
为了使项目便于维护，以及增强代码的可读性，我们有必要对“大方法”的逻辑进行整理，并提取出分散的“小方法”。
这就是本文要讲的两种重构策略：提取方法、提取方法对象。
如何快速地找到想读的书？
在生活中，我是一个比较随意的人，平时也买了不少书去看。
我的书柜不够大，且已经装满了书，每当读完一本书时，我懒得花些时间整理，想着以后再去整理这些书籍，所以我通常都将这些书塞到一个大箱子里面。
每次要重读某些书时，我恨不得把这个箱子翻个底朝天，在花费“九牛二虎之力”之后，我终于找到了要看的书。
然后，我把其他翻出来的书再塞回去。
箱子那么大，所有的书都放在一个箱子里，一整箱书都没有分类，有些书藏得很深，找起书来的确不方便。
后来，我想到了一个方法——最近快递小哥送货的包装纸箱还在家里，这些箱子不会很大，但装书应该绰绰有余，何不把这些箱子利用起来？
于是，我就动手挑选了一些大小合适的小纸箱，用签字笔给每个纸箱做了一个标记。
1号纸箱，装ASP.NET编程相关的书
2号纸箱，装架构设计相关的书
3号纸箱，装管理相关的书
…
N号纸箱，装旅游相关的书
在生活中，很多读者可能也遇到过此类问题，为什么找个东西就这么难呢？
结果就是抱着这种心理，这个方法一直到项目上线都没有整理过。
在项目维护期间，需要修改这个方法时，再次阅读到这个方法，我们不禁抱怨：“我擦，这方法怎么这么长，这是谁写的，我给他666！哎呦，不对，这好像是我自己写的！”
提取方法
当一个方法包含实现一个功能的所有逻辑时，不仅方法会看起来比较臃肿（可读性差），也会给将来的维护造成困扰，每次改动都会让你如履薄冰，并且较大可能带来新的bug。这不符合我们“将来的利益”，我们可以使用提取方法的重构策略来规避这个问题。
下面是我对提取方法的定义：
如果一个方法包含多个逻辑，我们应将每个逻辑提取出来，并确保每个方法只做一件事情。
下图表示了这个重构策略（蓝色为重构前，红色为重构后）。
示例
重构前
下面这段代码定义了一个Receipt类，用于描述收入信息，并计算总收入。
using System.Collections.Generic;
namespace ExtractMethod.Before
{
public class Receipt
{
public IList<decimal> Discounts { get; set; }
public IList<decimal> ItemTotals { get; set; }
public decimal CalculateGrandTotal()
{
decimal subTotal = 0m;
// 计算subTotal
foreach (decimal itemTotal in ItemTotals)
subTotal += itemTotal;
// 计算折扣
if (Discounts.Count > 0)
{
foreach (decimal discount in Discounts)
{
subTotal -= discount;
}
}
// 计算税额
decimal tax = subTotal*0.065m;
subTotal += tax;
return subTotal;
}
}
}
CalculateGrandTotal()方法包含了多处逻辑：计算subTotal，计算折扣，计算税额。
这几处逻辑是相对独立的，我们可以将其提取出来，重构为3个方法。
重构后
重构后，CalculateGrandTotal()方法只包含调用各个子方法的逻辑，这已经精简了很多，可读性也有所增强。
using System.Collections.Generic;
using System.Linq;
namespace ExtractMethod.After
{
public class Receipt
{
public IList<decimal> Discounts { get; set; }
public IList<decimal> ItemTotals { get; set; }
public decimal CalculateGrandTotal()
{
// 计算subTotal
decimal subTotal = CalculateSubTotal();
// 计算折扣
subTotal = CalculateDiscounts(subTotal);
// 计算税额
subTotal = CalculateTax(subTotal);
return subTotal;
}
// 计算subTotal
private decimal CalculateSubTotal()
{
return ItemTotals.Sum();
}
// 计算折扣
private decimal CalculateDiscounts(decimal subTotal)
{
if (Discounts.Count > 0)
{
subTotal = Discounts.Aggregate(subTotal, (current, discount) => current - discount);
}
return subTotal;
}
// 计算税额
private decimal CalculateTax(decimal subTotal)
{
decimal tax = subTotal * 0.065m;
subTotal += tax;
return subTotal;
}
}
}
二次重构
我认为这仍然不够。CalculateGrandTotal() 方法所表现的“语义”，是为了计算收入总额。
但上面这段代码不能让我们快速地知道这个语义，我们需要通过3个子方法来理解这个语义。
“计算收入总额”本质上是有一个公式的，即“收入总额 = （各项子收入总和 - 折扣总和） * （1 + 税率）”，公式的右侧是一个简单的三项式。
这个方法没有体现”公式“这个概念，为了让这段代码OO的味道更浓厚一些。
我们再次对其重构，将公式右侧的每一项提取为属性，每一项的计算逻辑都通过get属性体现。
using System.Collections.Generic;
using System.Linq;
namespace ExtractMethod.After
{
public class Receipt2
{
private IList<decimal> Discounts { get; set; }
private IList<decimal> ItemTotals { get; set; }
public decimal CalculateGrandTotal()
{
// 收入总额 = （各项子收入总和 - 折扣总和） * （1 + 税率）
decimal grandTotal = (SubTotal - TotalDiscounts) * (1 + TaxRate);
return grandTotal;
}
// 获取subTotal
private decimal SubTotal
{
get { return ItemTotals.Sum(); }
}
// 获取TotalDiscounts
private decimal TotalDiscounts
{
get { return Discounts.Sum(); }
}
// 获取TaxRate
private decimal TaxRate
{
get { return 0.065m; }
}
}
}
再次重构后的代码，是不是一目了然？
这里可能有人会疑惑了，本文不是讲提取方法的吗？现在怎么去提取属性了呢？
在C#中，属性的本质是字段的get, set方法，所以它仍然算是提取方法。
请注意，并不是所有情况下，都适合使用提取属性来代替提取方法。我的建议是，当提取的方法逻辑较少时，可以使用提取属性代替。当提取的方法逻辑较多时，如果使用提取属性代替，也会让人觉得困扰。因为属性是为了描述对象的特征，描述特征的过程如果较为复杂，会让人难以理解，我们应该keep it simple!
提取方法对象
以上示例描述了一个客观对象：“收入”，这个对象包含两个层面的“语义”——“收入相关的信息”和“计算收入的方法”。
“收入相关的信息”用名词来体现，它揭示了收入客观存在的特征（例如：所有的子收入、折扣和税率）。
“计算收入的方法”用动词来体现，它揭示了收入的计算过程。
这两层“语义”可以看做两种不同的职责，为了将这两层“语义”隔离开来，我们可以将“计算收入的方法”提取为一个新的对象。
using System.Collections.Generic;
using System.Linq;
namespace ExtractMethod.After
{
/// <summary>
/// 描述收入相关的信息
/// </summary>
public class Receipt
{
public IList<decimal> Discounts { get; set; }
public IList<decimal> ItemTotals { get; set; }
// 获取TaxRate
public decimal TaxRate
{
get { return 0.065m; }
}
public decimal CalculateGrandTotal()
{
return new ReceiptCalculator(this).CalculateGrandTotal();
}
}
/// <summary>
/// 描述收入的计算方法
/// </summary>
public class ReceiptCalculator
{
private readonly Receipt _receipt;
public ReceiptCalculator(Receipt receipt)
{
_receipt = receipt;
}
public decimal CalculateGrandTotal()
{
decimal grandTotal = (SubTotal - TotalDiscounts) * (1 + _receipt.TaxRate);
return grandTotal;
}
// 获取subTotal
private decimal SubTotal
{
get { return _receipt.ItemTotals.Sum(); }
}
// 获取TotalDiscounts
private decimal TotalDiscounts
{
get { return _receipt.Discounts.Sum(); }
}
}
}
这则代码将Receipt对象的“计算收入的方法”提取到了ReceiptCalculator对象，Receipt对象则只保留了属性和精简的CalculateGrandTotal()方法。
“提取方法对象”也是一个不错的重构策略，“提取方法对象”有什么作用呢？它可以精确类的职责，控制类的粒度。
一开始，我们用Receipt来描述“收入”这件事情；后来我们发现这件事情可以拆分为两个细节，“收入相关的信息”和“计算收的方法”，于是我们将这两个细节拆分开来。
到这里，也许大家又能看出一点点”OO”的味道了，它体现了我们看待客观事物的角度，以及对客观事物的理解程度。OO的过程是我们对客观事物的探索和认知过程，它也会随着我们了解到更多的事物细节而进化。