学习之路三十三：重构技巧的学习

最近看了圣殿骑士大哥的重构文章，其中有几个重构技巧让我颇有感触，特此记录下。

文章地址：31天重构学习笔记重新整理下载

1.封装集合，返回集合接口类型 

　　这个技巧让我想起了项目中的代码，比如：

    public class Check
    {
        private List<Detail> _details = new List<Detail>();

        public IList<Detail> GetDetails()
        {
            return _details;
        }
    }

    public class Detail
    {
        public string Name { get; set; }
    }

 　  如果这样设计，那么用户通过调用GetDetails方法之后就可以对你的集合做任意的改动，这样的做法是非常危险的，所以必须要改进。

　　重构原则：返回可迭代器类型接口来保证对集合的封装，改进如下：

    public class Check
    {
        private List<Detail> _details = new List<Detail>();

        private Dictionary<int, Detail> _specificDetail = new Dictionary<int, Detail>();

        public IEnumerable<Detail> GetDetails()
        {
            return _details;
        }

        public IEnumerable<KeyValuePair<int, Detail>> GetSpecificDetail()
        {
            return _specificDetail;
        }
    }

    public class Detail
    {
        public string Name { get; set; }
    }

　　迭代器文章入口：迭代器学习之一：使用IEnumerable和IEnumerator接口

 　  我将在项目中运用此重构技巧。

2.提取判断条件作为方法 - 方法名要有意义

　　当遇到复杂的判断后，如果没有注释，很多人第一眼都不会理解这个判断是做什么的。

　　所以把复杂的判断条件提取为方法，再取个有意义的名字，那么别人看一眼就明白做什么的，比如：

    public class Check
    {
        public Detail GetDetail { get; set; }

        public void SendMessage()
        {
            //这样的判断别人根本不知道是干什么的
            if (GetDetail != null && GetDetail.Number > 0)
            {
                //Send Message
            }

            //重构后的代码
            //这样别人就知道这个判断的作用：判断当前的信息有没有提交
            if (HasConfirm(GetDetail))
            {
                //Send Message
            }
        }

        public bool HasConfirm(Detail detail)
        {
            return GetDetail != null && GetDetail.Number > 0;
        }
    }

    public class Detail
    {
        public int Number { get; set; }
    }

3.为带有大量bool参数的方法重新进行拆分组合

　　这个重构手法在项目中还没有用过，方法带有大量的bool参数本来就很奇葩，不过如果真的遇到了，我们也有应对方法，如下：

    public class Test
    {
          //如果是这样的一个方法，你知道它是干什么的吗，根本就不能理解它的用意
        private void Create(bool isA, bool isB, bool isC)
        { }
    }

 　　重构后的代码：

    public class Test
    {
        //进行拆分后在重新组合
        public void CreateA()
        {
            this.Create(true, false, false);
        }

        public void CreateB()
        {
            this.Create(false, true, false);
        }

        public void CreateC()
        {
            this.Create(false, false, true);
        }

        private void Create(bool isA, bool isB, bool isC)
        { }
    }

 4.避免双重否定

　　其实这个重构手法我理解为尽量避免使用在if条件里使用 - “!”.

　　因为如果本来你的判断条件就是表达否定的意思，那么在加上一个否定的判断，那么就会是双重否定。

　　那别人理解起来是不是会很抓狂，他会在心理画个圈圈狠狠的诅咒你的，:-)，比如：

    public class Test
    {
        public void TestOne()
        {
            //本来想表达已经付款了，所以只能加个否定来判断咯
            //可是这个交别人理解起来真的很抓狂
            if (!NoPayment)
            {
                //TO DO
            }
        }

        public bool NoPayment { get; set; }
    }

 　　重构后的代码：

    public class Test
    {
        public void TestOne()
        {
            //本来想表达已经付款了，所以只能加个否定来判断咯
            //可是这个交别人理解起来真的很抓狂
            if (!NoPayment)
            {
                //TO DO
            }

            //重构后的代码
            //避免使用双重否定来作为判断条件
            if (HasPayment)
            {

            }
        }

        public bool NoPayment { get; set; }

        public bool HasPayment { get; set; }
    }

5.尽快返回 - 返回值

　　这个重构技巧可以分解复杂的判断条件，是那些冗余的判断分支化成简介的小分支，比如：

    public class TestOne
    {
        private List<Detail> _details;

        public void Display()
        {
            //这么一大长串的判断条件是不是很恶心
            if (_details != null)
            {
                if (_details.Count > 0)
                {
                    foreach (var item in _details)
                    {
                        if (item.Number > 0)
                        {
                            //TO DO
                        }
                    }
                }
            }
        }
    }

    public class Detail
    {
        public int Number { get; set; }
    }

 　　重构后的代码：

    public class TestOne
    {
        private List<Detail> _details;

        public void Display()
        {
            //重构之后是不是很清爽呀
            //哈哈
            if (_details == null || _details.Count <= 0)
                return;
            foreach (var item in _details.Where(p => p.Number > 0).Select(p => p))
            {
                //TO DO
            }
        }
    }

    public class Detail
    {
        public int Number { get; set; }
    }

以同步至：个人文章目录索引