c#设计模式之简单工厂

1.面向对象的3大属性，封装、继承、多态，以一个加单的计算机为例：

创建一个父类Operation 有两个属性 和一个计算方法（虚方法），便于子类重写：

 public class Operation
    {
        private double _numberA = 0;
        private double _numberB = 0;

        public double NumberA
        {
            get { return _numberA; }
            set { _numberA = value; }
        }

        public double NumberB
        {
            get { return _numberB; }
            set { _numberB = value; }
        }

        /// <summary>虚方法
        /// 
        /// </summary>
        /// <returns></returns>
        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    }

接下来创建计算类，加减乘除类来集成操作类

加类

 public class OperationAdd:Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }

减类

 public class OperationSub:Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }

乘类

 public class OperationMul:Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }

除类

 public class OperationDiv:Operation
    {
        public override double GetResult()
        {
            double result = 0;
            if (NumberB == 0)
                throw new Exception("除数不能为0");
            result = NumberA / NumberB;
            return result;
        }
    }

然后通过简单工厂类来创建计算的实例

 public class OperationFactory
    {
        public static Operation createOperate(string operate)
        {
            Operation oper = null;
            switch (operate)
            {
                case "+":
                    oper = new OperationAdd();
                    break;
                case "-":
                    oper = new OperationSub();
                    break;
                case "*":
                    oper = new OperationMul();
                    break;
                case "/":
                    oper = new OperationDiv();
                    break;
            }
            return oper;
        }
    }

最后通过界面去调用：

 static void Main(string[] args)
        {
            Operation oper;
            oper = OperationFactory.createOperate("+");
            oper.NumberA = 1;
            oper.NumberB = 2;
            double result = oper.GetResult();
            Console.WriteLine(result);
            Console.ReadKey();
        }

这里把计算过程都封装成一个方法，每个计算类又集成了操作类，这样由于每个方法都重写了计算方法，这里表现出一个方法的不同表现形态，如果以后要增加其他的方法，只需要继承操作类 重写计算方法即可，这样也不会对原有的程序进行修改，实现了解耦，面向对象语言的优点在于可维护性，可复用，可扩展、灵活性。

以上为自学的一点总结，希望有不对的地方，请大家指点，谢谢