zoukankan      html  css  js  c++  java
  • 31天重构学习笔记13. 提取方法对象

    概念:本文中的“提取方法对象”是指当你发现一个方法中存在过多的局部变量时,你可以通过使用“提取方法对象”重构来引入一些方法,每个方法完成任务的一个步骤,这样可以使得程序变得更具有可读性。

    正文:如下代码所示,Order 类中的Calculate方法要完成很多功能,在之前我们用“提取方法”来进行重构,现在我们采取“提取方法对象”来完成重构。

    using System.Collections.Generic;
    
    namespace LosTechies.DaysOfRefactoring.ExtractMethodObject.Before
    {
        public class OrderLineItem
        {
            public decimal Price { get; private set; }
        }
    
        public class Order
        {
            private IList<OrderLineItem> OrderLineItems { get; set; }
            private IList<decimal> Discounts { get; set; }
            private decimal Tax { get; set; }
    
            public decimal Calculate()
            {
                decimal subTotal = 0m;
    
                // Total up line items
                foreach (OrderLineItem lineItem in OrderLineItems)
                {
                    subTotal += lineItem.Price;
                }
    
                // Subtract Discounts
                foreach (decimal discount in Discounts)
                    subTotal -= discount;
    
                // Calculate Tax
                decimal tax = subTotal * Tax;
    
                // Calculate GrandTotal
                decimal grandTotal = subTotal + tax;
    
                return grandTotal;
            }
        }
    }

    正如下代码所示,我们引入了OrderCalculator类,该类实现了所有的计算方法,Order类将自身传递给 OrderCalculator类并调用Calculate方法完成计算过程。

    using System.Collections.Generic;
    
    namespace LosTechies.DaysOfRefactoring.ExtractMethodObject.After
    {
        public class OrderLineItem
        {
            public decimal Price { get; private set; }
        }
    
        public class Order
        {
            public IEnumerable<OrderLineItem> OrderLineItems { get; private set; }
            public IEnumerable<decimal> Discounts { get; private set; }
            public decimal Tax { get; private set; }
    
            public decimal Calculate()
            {
                return new OrderCalculator(this).Calculate();
            }
        }
    
        public class OrderCalculator
        {
            private decimal SubTotal { get; set; }
            private IEnumerable<OrderLineItem> OrderLineItems { get; set; }
            private IEnumerable<decimal> Discounts { get; set; }
            private decimal Tax { get; set; }
    
            public OrderCalculator(Order order)
            {
                OrderLineItems = order.OrderLineItems;
                Discounts = order.Discounts;
                Tax = order.Tax;
            }
    
            public decimal Calculate()
            {
                CalculateSubTotal();
    
                SubtractDiscounts();
    
                CalculateTax();
    
                return SubTotal;
            }
    
            private void CalculateSubTotal()
            {
                // Total up line items
                foreach (OrderLineItem lineItem in OrderLineItems)
                    SubTotal += lineItem.Price;
            }
    
            private void SubtractDiscounts()
            {
                // Subtract Discounts
                foreach (decimal discount in Discounts)
                    SubTotal -= discount;
            }
    
            private void CalculateTax()
            {
                // Calculate Tax
                SubTotal += SubTotal * Tax;
            }
        }
    }

    总结:本文的重构方法在有的时候还是比较有用,但这样会造成字段的增加,同时也会带来一些维护的不便,它和“提取方法”最大的区别就是一个通过方法返回需要的数据,另一个则是通过字段来存储方法的结果值,所以在很大程度上我们都会选择“提取方法”。

  • 相关阅读:
    107. Binary Tree Level Order Traversal II
    103. Binary Tree Zigzag Level Order Traversal
    102. Binary Tree Level Order Traversal
    690. Employee Importance
    1723. Find Minimum Time to Finish All Jobs
    LeetCode 329 矩阵中最长增长路径
    7.2 物理内存管理
    LeetCode 面试题 特定深度节点链表
    LeetCode 100 相同的树
    npm安装包命令详解,dependencies与devDependencies实际区别
  • 原文地址:https://www.cnblogs.com/ywsoftware/p/2892592.html
Copyright © 2011-2022 走看看