README.md

Today’s refactoring didn’t really come from any one source. It just named it although someone else may have something similar that’s named differently. If you know of anyone that has a name for this other than Break Method, please let me know.

This refactoring is kind of a meta-refactoring in the fact that it’s just extract method applied over and over until you decompose one large method into several smaller methods.

This example here is a tad contrived because the AcceptPayment method isn’t doing as much as I wanted. Imagine that there is much more supporting code around each action that the one method is doing. That would match a real world scenario if you can picture it that way. Below we have the AcceptPayment method that can be decomposed multiple times into distinct methods.

public class Product {
	private double price;
	private double discount;
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	public double getDiscount() {
		return discount;
	}
	public void setDiscount(double discount) {
		this.discount = discount;
	}
}

public class Customer {
	public void deductFromCustomerBalance(double amount){
		//deduct from balance
	}
}

public class CashRegister {
	private static final double tax = 0.06;

	public void acceptPayment(Customer customer, List<Product> products, double payment) {
		double subTotal = 0;
		for(Product product: products){
			subTotal += product.getPrice();
		}
		for(Product product: products){
			subTotal -= product.getDiscount();
		}
		double grandTotal = subTotal + subTotal * tax;
		customer.deductFromCustomerBalance(grandTotal);

	}
}

As you can see the AcceptPayment method has a couple of things that can be decomposed into targeted methods. So we perform the Extract Method refactoring a number of times until we come up with the result:

public class Product {
	private double price;
	private double discount;
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	public double getDiscount() {
		return discount;
	}
	public void setDiscount(double discount) {
		this.discount = discount;
	}
}

public class Customer {
	public void deductFromCustomerBalance(double amount){
		//deduct from balance
	}
}

public class CashRegister {
	private static final double tax = 0.06;

	//This is an impure method - not a good thing. 
	public void acceptPayment(Customer customer, List<Product> products, double payment) {
		double subTotal = calculateSubTotal(products);
		subTotal = subtractDiscounts(products);
		double grandTotal = addTax(subTotal);
		subtractFromCustomerBalance(customer, grandTotal);
	}

	private double calculateSubTotal(List<Product> products) {
		double subTotal = 0.0;
		for (Product product : products) {
			subTotal += product.getPrice();
		}
		return subTotal;
	}

	private double subtractDiscounts(List<Product> products) {
		double subTotal = 0.0;
		for (Product product : products) {
			subTotal -= product.getDiscount();
		}
		return subTotal;
	}

	private double addTax(double subTotal) {
		return subTotal + subTotal * tax;
	}

	private void subtractFromCustomerBalance(Customer customer, double amount) {
		customer.deductFromCustomerBalance(amount);
	}
}

Original C# code from the book:

public class CashRegister {
	public CashRegister() {
		Tax = 0.06m;
	}
	
	private decimal Tax { get; set; }
	
	public void AcceptPayment(Customer customer, IEnumerable<Product> products,decimal payment) {
		decimal subTotal = 0m;
		foreach (Product product in products) {
			subTotal += product.Price;
		}
		foreach(Product product in products) {
			subTotal -= product.AvailableDiscounts;
		}
		decimal grandTotal = subTotal * Tax;
		customer.DeductFromAccountBalance(grandTotal);
	}
}
public class Customer {
	public void DeductFromAccountBalance(decimal amount) {
  		// deduct from balance
  		}
}
public class Product {
	public decimal Price { get; set; }
	public decimal AvailableDiscounts { get; set; }
} 

//Solution:
public class CashRegister {
	public CashRegister() {
		Tax = 0.06m;
	}
	
	private decimal Tax { get; set; }
	private IEnumerable<Product> Products { get; set; }
	
	public void AcceptPayment(Customer customer, IEnumerable<Product> products, decimal payment) {
		decimal subTotal = CalculateSubtotal();
		subTotal = SubtractDiscounts(subTotal);
		decimal grandTotal = AddTax(subTotal);
		SubtractFromCustomerBalance(customer, grandTotal);
	}
	
	private void SubtractFromCustomerBalance(Customer customer, decimal grandTotal) {
		customer.DeductFromAccountBalance(grandTotal);
	}
 	private decimal AddTax(decimal subTotal) {
 		return subTotal * Tax;
 	}
 	private decimal SubtractDiscounts(decimal subTotal) {
 		foreach(Product product in Products) {
 			subTotal -= product.AvailableDiscounts;
 		}
 		return subTotal;
 	}
 	private decimal CalculateSubtotal() {
 		decimal subTotal = 0m;
 		foreach (Product product in Products) {
 			subTotal += product.Price;
 		}
 		return subTotal;
 	}
}

public class Customer {
	public void DeductFromAccountBalance(decimal amount) {
		// deduct from balance
	}
}

public class Product {
	public decimal Price { get; set; }
	public decimal AvailableDiscounts { get; set; }
}