大话设计模式之工厂模式 C#

学无止境，精益求精

十年河东，十年河西，莫欺少年穷

学历代表你的过去，能力代表你的现在，学习代表你的将来

大话设计模式一书中第一个开讲的设计模式是简单工厂模式，关于简单工厂模式大家可参考鄙人的博客：代码无错就是优？简单工厂模式 C#

当然，本篇博客所讲的工厂模式和简单工厂模式还是非常类似的，因此，在进行工厂模式讲解之前，我们有必要重温下简单工厂模式

何为工厂模式？不论是简单工厂模式还是本篇的工厂模式，其工厂类主要负责生产对象，然后通过相应的对象调用相关的方法

在重温简单工厂模式之前，我们再次看下简单工厂模式的UML类图

针对上述的简单工厂模式UML类图，我们得到如下叙述：

1、简单工厂类是和运算类是有关联的（实线加箭头代表关联），简单工厂类的主要功能是生产运算对象

2、运算类用斜体表示，说明运算类为抽象类，运算类有两个属性及一个返回值为 double 的方法

3、加减乘除类继承运算类并实现GetResult()方法。

针对上述三点叙述，我们可用如下代码来实现（如果你还看不懂UML类图，可以参考鄙人博客：UML类图应该怎么看？）

    public class 简单工厂类

    {

        double NumberA, NumberB;

        public 简单工厂类() { }

        public 简单工厂类(double A, double B)

        {

            this.NumberA = A;

            this.NumberB = B;

        }

        double Oper = new double();

        public double Operate(string 符号)

        {

            switch (符号)

            {

                case "+": Oper = new 加法类().GetResult(NumberA, NumberB); break;

                case "-": Oper = new 减法类().GetResult(NumberA, NumberB); break;

                case "*": Oper = new 乘法类().GetResult(NumberA, NumberB); break;

                case "/": Oper = new 除法类().GetResult(NumberA, NumberB); break;

            }

            return Oper;

        }

    }

    public abstract class 运算类

    {

        public abstract double GetResult(double NumberA, double NumberB);

    }

    public class 加法类:运算类

    {

        public override double GetResult(double NumberA, double NumberB)

        {

            return NumberA + NumberB;

        }

    }

    public class 减法类 : 运算类

    {

        public override double GetResult(double NumberA, double NumberB)

        {

            return NumberA - NumberB;

        }

    }

    public class 乘法类 : 运算类

    {

        public override double GetResult(double NumberA, double NumberB)

        {

            return NumberA * NumberB;

        }

    }

    public class 除法类 : 运算类

    {

        public override double GetResult(double NumberA, double NumberB)

        {

            if (NumberB != )

                return NumberA / NumberB;

            else throw new Exception("被除数不能为零");

        }

    }

        static void Main(string[] args)

        {

            double A = ;

            double B = ;

            string F = "/";

            简单工厂类 M = new 简单工厂类(A,B);

            double Result =  M.Operate(F);

            Console.WriteLine(Result);

            Console.ReadKey();

        }

上述代码是鄙人看着UML类图自己设计的，和博客：代码无错就是优？简单工厂模式 C# 中的设计代码并不一样！当然，这两种代码都准确的表达的简单工厂的理念。有兴趣的也可以看下代码无错就是优？简单工厂模式中的代码实现形式。

OK，上述就是简单工厂模式的代码设计方案！

但是简单工厂模式违反了设计模式的开闭原则，所以我们有必要对其进一步优化！

所谓开闭原则：

这个原则其实有两个特性，一个是说对于扩展是开放的，另一个是说，对于修改是封闭的（ASD原则）

如何优化呢？

工厂模式闪亮登场...

首先看下工厂模式关于加减乘除的UML类图

额，似乎复杂了很多！

不急，我们慢慢分析，然后再用代码实现！

1、运算工厂接口依赖运算类，加法工厂类依赖加法类，减法工厂类依赖减法类，乘法工厂类依赖乘法类，除法工厂类依赖除法类！（虚线加箭头代表依赖）

2、加减乘除工厂类继承运算工厂接口，加减成熟类继承运算类（三角加实线代表继承）

3、下方的M的N次方类和对应的工厂类是用来扩展的。

那么，分析了UML类图的信息，怎样用代码实现呢？

首先我们来创建左侧部分的五个类（运算类及加减乘除类），如下：

    /// <summary>

    /// 运算类

    /// </summary>

    public class Operation

    {

        public double NumberA, NumberB;

        public virtual double GetResult()

        {

            return ;

        }

    }

    public class Add : Operation

    {

        public override double GetResult()

        {

            return NumberA + NumberB;

        }

    }

    public class Sub : Operation

    {

        public override double GetResult()

        {

            return NumberA - NumberB;

        }

    }

    public class Mul : Operation

    {

        public override double GetResult()

        {

            return NumberA * NumberB;

        }

    }

    public class Div : Operation

    {

        public override double GetResult()

        {

            if (NumberB == )

                throw new Exception("被除数不能为零");

            return NumberA / NumberB;

        }

    }

其次，我们来构建右侧部分的一个接口及四个类（加减乘除工厂类），如下：

    public interface IFactory

    {

        Operation GetOperation();

    }

    public class AddFactory : IFactory

    {

        public Operation GetOperation()

        {

            return new Add();

        }

    }

    public class SubFactory : IFactory

    {

        public Operation GetOperation()

        {

            return new Sub();

        }

    }

    public class MulFactory : IFactory

    {

        public Operation GetOperation()

        {

            return new Mul();

        }

    }

    public class DivFactory : IFactory

    {

        public Operation GetOperation()

        {

            return new Div();

        }

    }

客户端代码为：

        static void Main(string[] args)

        {

            IFactory F = new AddFactory();

            Operation AM = F.GetOperation();

            AM.NumberA = ;

            AM.NumberB = ;

            double sum = AM.GetResult();

            Console.WriteLine(sum);

            Console.ReadKey();

        }

最后，我们来运行一下（7+8=15）：

写到这儿，我可以自豪的说：如果你要加平方根运算，我只需新增平方根类及平方根工厂。因此，现在的设计是不违反设计模式的开闭规则的！

我们知道，在简单工厂模式中，我们可以通过运工厂类的 Switch Case 来判断具体的运算类型，但是上述所写的工厂模式却做不到了！这样写无形中加重了客户端的负担（客户端必须自己来判断运算类型），因此：有没有好的办法解决这个弊端呢？

答案是有，而且还有一个有趣的名字，叫：雷锋工厂

如何用代码实现呢？

@陈卧龙的博客

巴特西

大话设计模式之工厂模式 C#

最新文章

热门文章