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

    本笔记摘抄自:https://www.cnblogs.com/PatrickLiu/p/7551373.html,记录一下学习过程以备后续查用。

    一、引言

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

    二、简单工厂模式的介绍

    无论是简单工厂还是复杂工厂,首先它们都是工厂,工厂是干什么的呢? 在现实生活中的工厂是负责生产产品的。比如我们要吃饼干不用自己做,去超

市买就好了,因为有工厂已经把饼干生产好了。生产是工厂的任务,买来吃是我们自己的事,两者互不干涉,挺好。

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

工厂的概念就是指可以生产某个类型对象实例的一个类型

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

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

我们就不得不去修改此类的源码。此时我们可以运用面向对象(OOP)很重要的原则去解决这一类的问题,就是封装变化点。既然要封装改变点,自然也

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

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

    生活中,假如自己在家做饭吃,除了要买菜、洗菜、烧菜外,还有烦人的洗碗、刷锅等。而假如我们去外面吃饭的话,就完全没有上述这些麻烦,只需

要到餐馆点菜付款就可以了,其它的事全部由餐馆搞定,此时餐馆就充当简单工厂的角色。

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

    2.1、自己做饭的情况

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

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

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

        /// 
        /// 简单工厂模式:自己做饭的情况
        /// 没有简单工厂,自个儿想吃什么菜只能自己炒。
        /// 
        public class Oneself
        {
            /// 
            /// 烧菜方法
            /// 
            /// 菜名
            /// 
            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
    {
        /// 
        /// 简单工厂模式:菜抽象类
        /// 
        public abstract class Food
        {
            //输出点了什么菜
            public abstract void Print();
        }

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

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

        /// 
        /// 简单工厂模式:简单工厂类,负责烧菜。
        /// 
        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

    运行结果如下:

    简单工厂模式在很多时候可以叫做静态工厂模式(因为工厂类都定义了一个静态方法),由一个工厂类根据传入的参数决定创建出哪一种产品类的实例

(通俗点表达:通过客户下的订单来负责烧那道菜)。

    三、优点与缺点

    看完简单工厂模式的实现之后,很多人肯定会有这样的疑惑--我们只是把变化的代码移到了工厂类中罢了,好像没有其它的变化了。如果客户想吃其它

菜时,此时我们还是需要修改工厂类中的方法,也就是多加case语句(没应用简单工厂模式之前,修改的是客户类)。我首先要说:大家想的很对,每种

设计模式只会解决一种问题,它们有自己的使用场景,没有一种模式可以解决所有问题,这个就是简单工厂模式的缺点所在(这个缺点后面介绍的工厂方

法模式可以很好地解决)。

    3.1、简单工厂模式的优点

    1)简单工厂模式解决了客户端直接依赖于具体对象的问题。客户端可以消除直接创建对象的责任,而仅仅是消费产品。

    2)简单工厂模式实现了对责任的分割,也起到了代码复用的作用,因为之前的实现(自己做饭的情况)中,换了一个人同样要去在自己的类中实现做

菜的方法,然后有了简单工厂之后,去餐馆吃饭的所有人都不用那么麻烦了,只需要负责消费就可以了,此时简单工厂的烧菜方法就让所有客户共用了。

    3.2、简单工厂模式的缺点

    1)工厂类集中了所有产品创建逻辑,一旦不能正常工作,整个系统都会受到影响(通俗地意思就是:一旦餐馆没饭或者关门了,很多不愿意做饭的人就

没饭吃了)。

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

    3.3、简单工厂的使用场景

    1)当工厂类负责创建的对象比较少时可以考虑使用简单工厂模式。

    2)客户如果只知道传入工厂类的参数,对于如何创建对象的逻辑不关心时可以考虑使用简单工厂模式。 

    四、.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仍然未改动这部分代码。

    五、总结

    说起简单工厂,其实是一个很容易的工厂,可能很多人可能有意或者无意的使用过模式。模式不要太关注实现细节,要关注模式得出的原因及分析问题的

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

你可能感兴趣的:(C#设计模式学习笔记:简单工厂模式(工厂方法模式前奏篇))