重构-改善既有代码的设计（一）switch statements

　　《重构-改善既有代码的设计》是一本好书，值得大家去反复看几遍，对后面学习设计模式有很好的帮助。设计模式猛一看，会很晕，云里雾里的，所以可以从重构开始，一点一点改善代码的设计，然后重构到模式，这样可以理解的更透侧，更容易消化。

　　书中会列举出很多的坏味道bad smell，然后重构这些bad smell，增加复用性。其中一个就是当你使用switch的时候，尤其是case的东西定义了枚举类型的话，很多时候都可以用面向对象的多态很好的解决。要不然就是当你多一个枚举值的时候，需要修改原来的每一个switch，在每个里面添加一个case。

　　近来在写一段程序的时候，大概需求是员工，有几个种类的员工，工程师，销售人员。设计好数据库就直接使用代码生成工具，生成了一大堆代码，设计的时候考虑到工程师或者销售人员数据量会很大，所以就放在了两个表中。

　　这样就生成连个类engineer和salesman，和一些类的操作代码，就是一些add、delete、modify和get。

　　就开始写后面的业务代码了，写的过程中发现engineer和salesman还是有很多是一样的，比如说username、password、logonname、birthday等等，就在业务层定义了一个employee类，类里面有一个属性叫做employeeType，初始化employee的时候会赋值，就是表明当前员工是engineer还是salesman。

　

 

代码

<!--<br/ /><br/ />Code highlighting produced by Actipro CodeHighlighter (freeware)<br/ />http://www.CodeHighlighter.com/<br/ /><br/ />-->using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
    enum employeeType1
    {
        engineer,
        salesman
    }
    class employee11
    {
        private  employeeType _empType;
        private int _id;
        public employee11(employeeType empType)
            : this(empType, 0)
        {

        }
        public employee11(int id)
            : this(employeeType.engineer, id)
        {

        }
        public employee11(employeeType empType, int id)
        {
            this._empType = empType;
            this._id = id;
        }
        public void PrintSalary()
        {
            switch (_empType)
            {
                case employeeType.engineer:
                    engineer1 e = new engineer1(); 
                    e.PrintSalary();
                    break;
                case employeeType.salesman:
                    salesman1 s = new salesman1();
                    s.PrintSalary();
                    break;
            }
        }
        public void PrintName()
        {
            switch (_empType)
            {
                case employeeType.engineer:
                    engineer1 e = new engineer1();
                    e.PrintName();
                    break;
                case employeeType.salesman:
                    salesman1 s = new salesman1();
                    s.PrintName();
                    break;
            }
        }
    }
    class engineer1
    {

        public  void PrintSalary()
        {
            Console.WriteLine("your salary is {0}", 1000);
        }
        public void PrintName()
        {
            Console.WriteLine("your name is {0}", "shiwenbin");
        }
    }
    class salesman1
    {
        public void PrintSalary()
        {
            Console.WriteLine("your salary is {0}", 2000);
        }
        public void PrintName()
        {
            Console.WriteLine("your name is {0}", "swb");
        }
    }
}

 

 

 

　　如果后面要添加一个新员工类型，比如说boss，这样的话，首先要修改枚举employeeType1，然后要建立一个boss类，然后写上操作代码，还要在员工类employee11中的所有switch中都添加一个case，判断是否boss，然后调用boss的方法。

　　新添加一个员工类型，修改代码是必然的，但是可以控制在一定的范围内，代码应该对修改封闭，对增加开发，这也是一个代码设计原则。有一种办法，例如面向对象的多态，可以很好的解决这个问题，使得下次增加员工类型的话，只是修改枚举量和新建一个员工类，其他的什么都不用动了。只要将上面的类改造为下面的内容。

　　

代码

<!--<br/ /><br/ />Code highlighting produced by Actipro CodeHighlighter (freeware)<br/ />http://www.CodeHighlighter.com/<br/ /><br/ />-->using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
    enum employeeType
    {
        engineer,
        salesman
    }
    class employee1
    {
        protected employeeType _empType;
        protected int _id;
        public employee1(employeeType empType):this(empType,0)
        {

        }
        public employee1(int id):this(employeeType.engineer,id )
        {

        }
        public employee1(employeeType empType, int id)
        {
            this._empType = empType;
            this._id = id;
        }
        public virtual void PrintName()
        {

        }
        public virtual void PrintSalary()
        {

        }
        public virtual void Print()
        {
            Console.WriteLine("haha");
        }
        public override string ToString()
        {
            return string.Format("id is :{0}; type is {1}", _id, _empType);
        }
    }
    class engineer : employee1
    {

        public engineer(int id)
            : base(employeeType.engineer)
        {
            this._id = id;
        }
        public engineer()
            : base(employeeType.engineer)
        {
        }
        public override void PrintName()
        {
            Console.WriteLine("i am {0}", _empType.ToString());
        }
        public override void PrintSalary()
        {
            Console.WriteLine("your salary is {0}", 1000);
        }
        public override string ToString()
        {
            return string.Format("id is :{0}; type is {1}", _id, _empType);
        }
    }
    class salesman : employee1
    {

        public salesman(int id)
            : base(employeeType.salesman)
        {
            this._id = id;
        }
        public salesman()
            : base(employeeType.engineer)
        {
        }
        public override void PrintName()
        {
            Console.WriteLine("i am {0}", _empType.ToString());
        }
        public override void PrintSalary()
        {
            Console.WriteLine("your salary is {0}", 2000);
        }
        public override string ToString()
        {
            return string.Format("id is :{0}; type is {1}", _id, _empType);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            engineer emp1 = new engineer(123);
            emp1.PrintName();
            emp1.PrintSalary();
            emp1.Print();
            Console.WriteLine(emp1.ToString());
            Console.WriteLine("------------------------------");
            salesman emp2 = new salesman(456);
            emp2.PrintSalary();
            emp2.Print();
            Console.WriteLine(emp2.ToString());
            Console.WriteLine("------------------------------");
            Console.ReadLine();
        }
    }
}

 

 

　　

 

　　也就是利用了继承和虚函数来实现多态，来实现对修改封闭，对增加开放。