设计模式系列之——设计模式之工厂模式（factory pattern）【C#】

今天，开始和大家分享软件开发中的23种设计模式，和大家一起进步。在疫情到处肆虐的时候，我们净下心提升点我们的能力，以确保我们在激烈的竞争中保留自己的一个生存的机会。
工厂顾名思义就是创建产品，根据产品是具体产品还是具体工厂可分为简单工厂模式和工厂方法模式，根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。该模式用于封装和管理对象的创建，是一种创建型模式。本文从一个具体的例子逐步深入分析，来体会三种工厂模式的应用场景和利弊。

1. 简单工厂模式

简单工厂模式对对象创建管理方式最为简单，因为其仅仅简单的对不同类对象的创建进行了一层薄薄的封装。该模式通过向工厂传递类型来指定要创建的对象，其UML类图如下：

下面通过使用C#语言来实现简单工厂模式。目标是要生产各类手机。
首先，我们定义一个生产手机的标准接口（相当于AbstractProduct），仅有一个制造方法。如下：

    public interface IPhone
    {
        ///
        /// Make a Phone.
        ///
        void Make();
    }

在C#的接口定义中，如果不指明接口是public的话，只能在程序集中访问。对于接口中的方法，不用进行访问级别申明，默认是public的。

下面实现华为手机的制造（ProductA)，如下：

public class HuaWeiPhone : IPhone
    {
        public HuaWeiPhone()
        {
            this.Make();
        }
        #region IPhone 成员

        public void Make()
        {
            Console.WriteLine("我厂生产华为手机。");
        }

        #endregion
    }

C#中对接口的实现以及对类的继承统一使用冒号。不像Java中使用关键字implements或者extends。

再来一个山寨版的苹果（相当于ProductB），如下：

public class ApplePhone : IPhone
    {
        public ApplePhone()
        {
            this.Make();
        }
        #region IPhone 成员

        public void Make()
        {
            Console.WriteLine("我厂生产苹果手机。不是Iphone。");
        }

        #endregion
    }

主程序：

class Program
    {
        static void Main(string[] args)
        {
            PhoneFactory factory = new PhoneFactory();
            IPhone huaweiPhone = factory.MakePhone("HuaWeiPhone"); // make huawei phone!
            IPhone applePhone = factory.MakePhone("ApplePhone"); // make applephone!
            Console.ReadLine();
        }
    }

2. 工厂方法模式(Factory Method)

和简单工厂模式中工厂负责生产所有产品相比，工厂方法模式将生成具体产品的任务分发给具体的产品工厂，其UML类图如下：也就是定义一个抽象工厂，其定义了产品的生产接口，但不负责具体的产品，将生产任务交给不同的派生类工厂。这样不用通过指定类型来创建对象了。而是通过指定类型来创建工厂，再由工厂制造产品。

接下来继续使用生产手机的例子来讲解该模式。

其中和产品相关的IPhone接口、HuaWeiPhone类和ApplePhone类的定义不变。

定义IFactory类：生产不同产品的工厂的接口：

    public interface IFactory
    {
        IPhone MakePhone();
    }

 HuaWeiFactory类：生产华为手机的工厂（ProductAFactory）:

public class HuaWeiFactory:IFactory
    {
        #region IFactory 成员

        public SampleFactory.IPhone MakePhone()
        {
            return new HuaWeiPhone();
        }

        #endregion
    }

AppleFactory类：生产苹果手机的工厂（ProductBFactory）:

public class AppleFactory : IFactory
    {
        #region IFactory 成员

        public SampleFactory.IPhone MakePhone()
        {
            return new ApplePhone();
        }

        #endregion
    }

主程序：

class Program
    {
        static void Main(string[] args)
        {
            IFactory huaweiFactory = new HuaWeiFactory();
            IFactory appleFactory = new AppleFactory();
            huaweiFactory.MakePhone(); // make huawei phone!
            appleFactory.MakePhone(); // make apple phone!
            Console.ReadLine();
        }
    }

3. 抽象工厂模式(Abstract Factory)

上面两种模式不管工厂怎么拆分抽象，都只是针对一类产品Phone（AbstractProduct），如果要生成另一种产品PC，应该怎么表示呢？

最简单的方式是把2中介绍的工厂方法模式完全复制一份，不过这次生产的是PC。但同时也就意味着我们要完全复制和修改Phone生产管理的所有代码，显然这是一个笨办法，并不利于扩展和维护。

抽象工厂模式通过在AbstarctFactory中增加创建产品的接口，并在具体子工厂中实现新加产品的创建，当然前提是子工厂支持生产该产品。否则继承的这个工厂可以什么也不干。

其UML类图如下：

从上面类图结构中可以清楚的看到如何在工厂方法模式中通过增加新产品接口来实现产品的增加的。

接下来我们继续通过华为和苹果产品生产的例子来解释该模式。

PC接口：定义PC产品的接口(IPCComputer)：

public interface IPCComputer
    {
        void Make();
    }

HuaWeiPC类：定义华为电脑产品(HuaweiPC)：

public class HuaWeiPCComputer : IPCComputer
    {
        public HuaWeiPCComputer()
        {
            this.Make();
        }

        #region IPCComputer 成员

        public void Make()
        {
            Console.WriteLine("生产华为笔记本电脑!");
        }

        #endregion
    }

ApplePC类：定义苹果电脑产品(MAC)：

public class ApplePCComputer : IPCComputer
    {
        public ApplePCComputer()
        {
            this.Make();
        }

        #region IPCComputer 成员

        public void Make()
        {
            Console.WriteLine("生产苹果笔记本电脑，不是IMac哦。");
        }

        #endregion
    }

下面需要修改工厂相关的类的定义：
IMultiProductFactory类：增加PC产品制造接口

public interface IMultiProductFactory
    {
        IPhone MakePhone();
        IPCComputer MakePCComputer();
    }

HuaWeiMultiProductFactory类：增加华为PC的制造（ProductFactory1）

public class HuaWeiMultiProductFactory : IMultiProductFactory
    {
        #region IMultiProductFactory 成员

        public SampleFactory.IPhone MakePhone()
        {
            return new HuaWeiPhone();
        }

        public IPCComputer MakePCComputer()
        {
            return new HuaWeiPCComputer();
        }

        #endregion
    }

AppleMultiProductFactory类：增加苹果PC的制造（ProductFactory2）

public class AppleMultiProductFactory : IMultiProductFactory
    {
        #region IMultiProductFactory 成员

        public SampleFactory.IPhone MakePhone()
        {
            return new ApplePhone();
        }

        public IPCComputer MakePCComputer()
        {
            return new ApplePCComputer();
        }

        #endregion
    }

主程序：

class Program
    {
        static void Main(string[] args)
        {
            IMultiProductFactory huaweiFactory = new HuaWeiMultiProductFactory();
            IMultiProductFactory appleFactory = new AppleMultiProductFactory();
            huaweiFactory.MakePhone(); // make huawei phone!
            huaweiFactory.MakePCComputer(); // make huawei PC!
            appleFactory.MakePhone(); // make apple phone!
            appleFactory.MakePCComputer(); // make apple PC!
            Console.ReadLine();
        }
    }

总结：

上面介绍的三种工厂模式有各自的应用场景，实际应用时能解决问题满足需求即可，可灵活变通，无所谓高级与低级。
其中简单工厂方法实现同种产品的各种实现，根据名称来确定生产哪类产品。
工厂方法将同种产品的各种实现都由各自的工厂来实现。在使用的时候由各种工厂来产生各自的产品。
而抽象工厂主要实现多类产品的生产。即每个工厂可生产不同的产品。

在实际的编程中，你可以根据你的实际情况来确定使用哪种工厂模式。
附件将我的UML和源码加载上。
FactoryPattern.rar