设计模式之工厂模式

      您是否已经掌握了面向对象的编程了？您是否已经理解了多态、封装、继承了？您是否觉得您写的代码已经非常便于维护了，有很强的扩展性，重复性了？如果不是，请多学习设计模式吧。

     本章仅局限在工厂模式的简单使用。

     什么是工厂模式？

一个单独的类用来创造实例的过程，就是工厂模式。

     为什么要用到工厂模式？

编程不能满足于写完代码运行结果正确就完事，时常考虑如何让代码更加简练，更加容易维护，容易扩展和复用，努力做到写出优雅的代码。

     下面举一个使用简单工厂模式的小例子：

     在这里我们尝试开发一个简单计算机。为了使程序低耦合，我们应该尽量使业务逻辑层跟UI展现层分开。

     首先先设计操作符类：

 1     public class Operation
 2     {
 3         private double numberA = 0;
 4         private double numberB = 0;
 5 
 6         public double NumberA
 7         {
 8             get { return numberA; }
 9             set { numberA = value; }
10         }
11 
12         public double NumberB
13         {
14             get { return numberB; }
15             set { numberB = value; }
16         }
17 
18         public virtual double GetResult()
19         {
20             double result = 0;
21             return result;
22         }
23     }

     这时候我们利用多态和继承，编写加、减、乘、除法操作符类。当然以后根据需求还可以添加更多操作符类。（可扩展）

 1     class OperationAdd : Operation
 2     {
 3         public override double GetResult()
 4         {
 5             double result = 0;
 6             result = NumberA + NumberB;
 7             return result;
 8         }
 9     }
10 
11     class OperationSub : Operation
12     {
13         public override double GetResult()
14         {
15             double result = 0;
16             result = NumberA - NumberB;
17             return result;
18         }
19     }
20 
21     class OperationMul : Operation
22     {
23         public override double GetResult()
24         {
25             double result = 0;
26             result = NumberA * NumberB;
27             return result;
28         }
29     }
30 
31     class OperationDiv : Operation
32     {
33         public override double GetResult()
34         {
35             double result = 0;
36             if (NumberB == 0)
37                 throw new Exception("Divisor can't be zero.");
38             result = NumberA / NumberB;
39             return result;
40         }
41     }

      好了，现在我们需要考虑一个问题，我们如何让计算机知道我是希望调用哪一个算法呢？

      对，使用工厂模式，要实例化谁，将来会不会增加实例化的对象，比如增加开根运算，这是很容易变化的地方，应该考虑用一个单独的类来做这个

创造实例的过程，这就是工厂。来，我们看下面的代码。

        public static Operation CreateOperate(string operate)
        {
            Operation oper = null;

            switch (operate)
            {
                case "+":
                    oper = new OperationAdd();
                    break;
                case "-":
                    oper = new OperationMin();
                    break;
                case "*":
                    oper = new OperationMul();
                    break;
                case "/":
                    oper = new OperationDiv();
                    break;
            }

            return oper;
        }

       工厂模式就是实例化出合适的对象，通过多态返回父类的方式实现了调用任何一个算法的方法。

       最后实现显示计算器的代码，当然这些代码可以重复用在Web应用、Windows应用、PDA、嵌入式等其它方便。（重复性）

        static void Main(string[] args)
        {
            string strA;
            string strB;
            double result;
            string strOper;

            try
            {
                Console.Write("Please input number A : ");
                strA = Console.ReadLine();
                Console.Write("Please input the operation : ");
                strOper = Console.ReadLine();
                Console.Write("Please input number B : ");
                strB = Console.ReadLine();

                Operation oper = OperationFactory.CreateOperate(strOper);
                oper.NumberA = Convert.ToDouble(strA);
                oper.NumberB = Convert.ToDouble(strB);

                result = oper.GetResult();

                Console.Write("The result is : " + result.ToString());
                Console.ReadLine();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error : " + ex.Message);
            }
        }

       这样一个简单的计算器就完成了，以后不管需求怎么改变，我们只需要更改增加各种复杂的运算类，在工厂添加要生产的分支就可以了。（重复性）

       当然显示界面怎么改变都是可以的，跟业务逻辑不发生任何关联。