C#设计模式学习笔记：简单工厂模式(工厂模式前奏篇)

    本笔记摘抄自：http://www.javashuo.com/article/p-uvoiywgw-du.html，记录一下学习过程以备后续查用。

    1、引言

    简单工厂模式并不属于GoF23里面的设计模式，其实它属于一个过渡的模式，这个模式是为了引出下一篇要讲的模式：工厂模式。

    2、简单工厂模式的介绍

    不管是简单工厂仍是复杂工厂，首先它们都是工厂，工厂是干什么的呢？ 在现实生活中的工厂是负责生产产品的。好比咱们要吃饼干不用本身作，去超

市买就行了，由于有工厂已经把饼干生产好了。生产是工厂的任务，买来吃是咱们本身的事，二者互不干涉，挺好。

    那么在面向对象的软件设计中提到的工厂是什么意思呢？既然也叫工厂，那确定也是生产产品的，只不过这个产品是一个对象的实例。在软件设计中，

工厂的概念就是指能够生产某个类型对象实例的一个类型。

    有了工厂，若是咱们要使用某个类型的实例，就直接告诉工厂就好了，它会提供给咱们想要的实例对象。而具体工厂是怎么生产的不用咱们管，这样我

们也省事了，这就是解耦。在日常编程中，当使用”new”关键字建立一个对象时，该类就依赖于这个对象，所以它们之间的耦合度比较高。当需求变化时，

咱们就不得不去修改此类的源码。此时咱们能够运用面向对象（OOP）很重要的原则去解决这一类的问题，就是封装变化点。既然要封装改变点，天然也

就要找到变化的代码，而后把变化的代码用类来封装，这样的一种思路也就是咱们简单工厂模式的实现方式了。

    下面经过一个现实生活中的例子来引出简单工厂模式：

    生活中，假如本身在家作饭吃，除了要买菜、洗菜、烧菜外，还有烦人的洗碗、刷锅等。而假如咱们去外面吃饭的话，就彻底没有上述这些麻烦，只需

要到餐馆点菜付款就能够了，其它的事所有由餐馆搞定，此时餐馆就充当简单工厂的角色。

    下面让咱们看看现实生活中的例子用代码是怎样来表现的？

    2.1本身作饭的状况

    class Program
    {
        /// <summary>
        /// 简单工厂模式：菜抽象类
        /// </summary>
        public abstract class Food
        {
            //输出点了什么菜
            public abstract void Print();
        }

        /// <summary>
        /// 简单工厂模式：西红柿炒鸡蛋
        /// </summary>
        public class TomatoesWithEggs : Food
        {
            public override void Print()
            {
                Console.WriteLine("一份西红柿炒蛋。");
            }
        }

        /// <summary>
        /// 简单工厂模式：土豆肉丝
        /// </summary>
        public class PotatosWithShreddedPork : Food
        {
            public override void Print()
            {
                Console.WriteLine("一份土豆肉丝。");
            }
        }

        /// <summary>
        /// 简单工厂模式：本身作饭的状况
        /// 没有简单工厂，自个儿想吃什么菜只能本身炒。
        /// </summary>
        public class Oneself
        {
            /// <summary>
            /// 烧菜方法
            /// </summary>
            /// <param name="dishName">菜名</param>
            /// <returns></returns>
            public Food Cook(string dishName)
            {
                Food food = null;
                if (dishName.Equals("西红柿炒蛋"))
                {
                    food = new TomatoesWithEggs();
                }
                else if (dishName.Equals("土豆肉丝"))
                {
                    food = new PotatosWithShreddedPork();
                }
                return food;
            }
        }

        static void Main(string[] args)
        {
            #region 简单工厂模式：本身作饭的状况
            Oneself oneself = new Oneself();
            var food = oneself.Cook("西红柿炒蛋");
            food.Print();
            Console.Read();
            #endregion
        }
    }

View Code

    运行结果以下：

    2.2外出就餐的状况

    有了餐馆（也就是简单工厂）以后，咱们就能够把这些操做交给餐馆去作，此时消费者（也就是咱们）对菜（也就是具体对象）的依赖关系从直接变成

间接的，这样就实现了面向对象的另外一个原则——下降对象之间的耦合度。

    class Program
    {
        /// <summary>
        /// 简单工厂模式：菜抽象类
        /// </summary>
        public abstract class Food
        {
            //输出点了什么菜
            public abstract void Print();
        }

        /// <summary>
        /// 简单工厂模式：西红柿炒鸡蛋
        /// </summary>
        public class TomatoesWithEggs : Food
        {
            public override void Print()
            {
                Console.WriteLine("一份西红柿炒蛋。");
            }
        }

        /// <summary>
        /// 简单工厂模式：土豆肉丝
        /// </summary>
        public class PotatosWithShreddedPork : Food
        {
            public override void Print()
            {
                Console.WriteLine("一份土豆肉丝。");
            }
        }

        /// <summary>
        /// 简单工厂模式：简单工厂类，负责烧菜。
        /// </summary>
        public static class FoodSimpleFactory
        {
            public static Food CreateFood(string dishName)
            {
                Food food = null;
                if (dishName.Equals("土豆肉丝"))
                {
                    food = new PotatosWithShreddedPork();
                }
                else if (dishName.Equals("西红柿炒蛋"))
                {
                    food = new TomatoesWithEggs();
                }
                return food;
            }
        }

        static void Main(string[] args)
        {
            #region 简单工厂模式：外出就餐的状况
            //顾客充当客户端，负责调用简单工厂来生产对象。即客户点菜，厨师（至关于简单工厂）负责烧菜(生产的对象)。

            //客户点一份西红柿炒蛋        
            Food food1 = FoodSimpleFactory.CreateFood("西红柿炒蛋");
            food1.Print();

            //客户点一份土豆肉丝
            Food food2 = FoodSimpleFactory.CreateFood("土豆肉丝");
            food2.Print();

            Console.Read();
            #endregion
        }
    }

View Code

    运行结果以下：

    简单工厂模式在不少时候能够叫作静态工厂模式（由于工厂类都定义了一个静态方法），由一个工厂类根据传入的参数决定建立出哪种产品类的实例

（通俗点表达：经过客户下的订单来负责烧那道菜）。

    3、优势与缺点

    看完简单工厂模式的实现以后，不少人确定会有这样的疑惑--咱们只是把变化的代码移到了工厂类中罢了，好像没有其它的变化了。若是客户想吃其它

菜时，此时咱们仍是须要修改工厂类中的方法，也就是多加case语句（没应用简单工厂模式以前，修改的是客户类）。我首先要说：你们想的很对，每种

设计模式只会解决一种问题，它们有本身的使用场景，没有一种模式能够解决全部问题，这个就是简单工厂模式的缺点所在（这个缺点后面介绍的工厂方

法模式能够很好地解决）。

    3.1简单工厂模式的优势

    1）简单工厂模式解决了客户端直接依赖于具体对象的问题。客户端能够消除直接建立对象的责任，而仅仅是消费产品。

    2）简单工厂模式实现了对责任的分割，也起到了代码复用的做用，由于以前的实现（本身作饭的状况）中，换了一我的一样要去在本身的类中实现作

菜的方法，而后有了简单工厂以后，去餐馆吃饭的全部人都不用那么麻烦了，只须要负责消费就能够了，此时简单工厂的烧菜方法就让全部客户共用了。

    3.2简单工厂模式的缺点

    1）工厂类集中了全部产品建立逻辑，一旦不能正常工做，整个系统都会受到影响（通俗地意思就是：一旦餐馆没饭或者关门了，不少不肯意作饭的人就

没饭吃了）。

    2）系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，这样就会形成工厂逻辑过于复杂。

    3.3简单工厂的应用场景

    1）当工厂类负责建立的对象比较少时能够考虑使用简单工厂模式。

    2）客户若是只知道传入工厂类的参数，对于如何建立对象的逻辑不关心时能够考虑使用简单工厂模式。 

    4、.NET中简单工厂模式的实现

    .NET中System.Text.Encoding类就实现了简单工厂模式，该类中的GetEncoding(int codepage)就是工厂方法，具体的代码能够经过Reflector反编译工具

进行查看。

    .NET中Encoding的UML图为：

    Encoding类中实现的简单工厂模式是简单工厂模式的一种演变，此时简单工厂类由抽象产品角色扮演，然而.NET中Encoding类是如何解决简单工厂模式

中存在的问题的呢（即若是新添加一种编码怎么办）？在GetEncoding方法里的switch函数有以下代码：

    switch (codepage)
    {
        .......
        default:
            unicode = GetEncodingCodePage(codepage);
            if (unicode == null)
            {
                unicode = GetEncodingRare(codepage); //当编码不多见时
            }
            break;
        ......
    }

    在GetEncodingRare方法里有一些不经常使用编码的实例化代码，微软正式经过这个方法来解决新增长一种编码的问题。（其实也就是列出全部可能的编码情

况），微软之因此以这样的方式来解决这个问题，多是因为如今编码已经稳定了，添加新编码的可能性比较低，因此在.NET 4.5仍然未改动这部分代码。

    5、总结

    提及简单工厂，实际上是一个很容易的工厂，可能不少人可能有意或者无心的使用过模式。模式不要太关注实现细节，要关注模式得出的缘由及分析问题的

方法。咱们必定要好好的记住面向对象的设计原则，而后好好的体会模式之美，理解就会更多一些。