【重构学习】08 条件表达式的重构

所谓条件表达式，就是分支语句，去掉分支语句咯

1、分解条件表达式

修改点：你有一个复杂的条件语句（就是if else语句）

做法：将条件表达式的三个部分分别提炼出独立函数

即

            if (A部分)
            {
                B部分;
            }
            else {
                C部分;
            }    

这三个部分都提炼成函数就好了。

2、合并条件表达式

修改点：你有一系列测试，都得到相同结果

做法：将这些测试合并成一个条件表达式,并将这个表达式提炼成一个独立函数

3、合并重复的条件片段

修改点：在条件表达式的每个分支上有着相同一段代码

做法：将这段重复代码搬移到条件表达式之外

4、移除控制标记

修改点：在一系列布尔表达式中，某个变量带有“控制标记”（control flag）的作用。

做法：以break语句或return语句取代控制标记

            bool isILoveYou=true;
            int[] loveNum=new int[100];
            for (int i=0; i < 100; i++) {
                if (isILoveYou) {
                    if (某种原因) {
                        isILoveYou = false;
                    }
                    Console.WriteLine(loveNum[i]);
                }
            }        

而isILoveYou就是控制标记，所以可以用continue，break，return这类跳出语句去移除控制标记

5、以卫语句取代嵌套条件表达式

修改点：函数中的条件逻辑使人难以看清正常的执行路径

做法：使用卫语句表现所有情况。

如果某个条件极其罕见，就应该单独检查该条件，并在该条件为真时立刻从函数中返回，这样的语句被称为“卫语句”。

6、以多态取代条件表达式

修改点：你手上有个条件表达式，它根据对象类型的不同而选择不同的行为

做法：将这个条件表达式的每个分支放进一个子类内的覆盖函数中，然后将原始函数声明为抽象函数。

如果你搞不清楚的话，你可以看一看我在 7、数据的重构 里面的第14点的代码，也许你会更清楚一点。

7、引入NULL对象

修改点：你需要再三检查某对象是否为NULL

做法：将NULL值替换为null对象

用了NULL值的代码：

class Program
    {
        static void Main(string[] args)
        {
            var roomList = new List<Room>();
            roomList.Add(new Room("低级房",new People("A先生")));
            roomList.Add(new Room("高级房"));

            foreach (var room in roomList) {
                if (room.Master != null) {
                    Console.WriteLine(room.Master.Name);
                }
            }
            Console.ReadKey();
        }
    }

    public class Room {
        public Room(string roomName,People people=null)
        {
            this.RoomName = roomName;
            this.Master = people;
        }
        public string RoomName { get; set; }
        public People Master { get; set; }
    }
    public class People
    {
        public People(string name) {
            this.Name = name;
        }
        public string Name { get; set; }
    }

改为

class Program
    {
        static void Main(string[] args)
        {
            var roomList = new List<Room>();
            roomList.Add(new Room("低级房",new People("A先生")));
            roomList.Add(new Room("高级房"));

            foreach (var room in roomList) {
                Console.WriteLine(room.RoomName + ":" + room.Master.Name);
            }
            Console.ReadKey();
        }
    }

    public class Room {
        public Room(string roomName,People people=null)
        {
            this.RoomName = roomName;
            this.Master = people;
        }
        public string RoomName { get; set; }
        public People Master { 
            get{
                return  _master==null?new NullPeople():_master;
            }
            set {
                _master = value;
            }
        }

        People _master;
    }
    public class People
    {
        public People()
        {
        }
        public People(string name) {
            this.Name = name;
        }
        public virtual string Name { get; set; }
        public virtual bool IsNULL()
        {
            return false;
        }
        public static People CreateNullPeople()
        {
            return new NullPeople();
        }
    }
    public class NullPeople:People{
        public NullPeople():base() { 
        
        }
        public override bool IsNULL(){
            return true;
        }
        public override string Name
        {
            get
            {
                return "无人";
            }
        }
    }

在这里不继承people可能更好一点，都继承一个自定义的接口IsNULLPeople，代码更好看一点。