重构-改善既有代码的设计（一）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。

　

 

代码

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的方法。

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

　　

代码

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();
        }
    }
}

 

 

　　

 

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