C#设计模式-1简单工厂模式Simple Factory）


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 简单的工厂模式
{
    //我们是一个食品生产工厂，都是生成吃的
    class Program
    {
        static void Main(string[] args)
        {
           var doxing=   CreateFoodFactory.Cook("雪饼");
           doxing.PrintFood();
           var doxing2=  CreateFoodFactory.Cook("酸奶");
           doxing2.PrintFood();
        }
    }
 
    //生产工厂  
    public class CreateFoodFactory
    {
        public static Food Cook(string type)
        {
            Food food = null;
            switch (type)
            {
                case "雪饼":
                    food = new 雪饼();
                    break;
                case "酸奶":
                    food = new 酸奶();
                    break;
            }
            return food;
        }
    }

    //生成食品的抽象类
    public abstract class Food
    {
        public abstract void PrintFood();
    }

    //生产食物
    public class 雪饼 : Food
    {

        public override void PrintFood()
        {
            Console.WriteLine("雪饼，雪饼……");
        }
    }
 
    public class 酸奶 : Food
    {
        public override void PrintFood()
        {
            Console.WriteLine("酸奶，酸奶……");
        }
    }
}

以上的代码很简单吧，基本都能够理解吧。

优点与缺点

看完简单工厂模式的实现之后，你和你的小伙伴们肯定会有这样的疑惑（因为我学习的时候也有）——这样我们只是把变化移到了工厂类中罢了，好像没有变化的问题，因为如果客户想吃其他菜时，此时我们还是需要修改工厂类中的方法（也就是多加case语句，没应用简单工厂模式之前，修改的是客户类）。我首先要说：你和你的小伙伴很对，这个就是简单工厂模式的缺点所在（这个缺点后面介绍的工厂方法可以很好地解决），然而，简单工厂模式与之前的实现也有它的优点：

简单工厂模式解决了客户端直接依赖于具体对象的问题，客户端可以消除直接创建对象的责任，而仅仅是消费产品。简单工厂模式实现了对责任的分割。
简单工厂模式也起到了代码复用的作用，因为之前的实现（自己做饭的情况）中，换了一个人同样要去在自己的类中实现做菜的方法，然后有了简单工厂之后，去餐馆吃饭的所有人都不用那么麻烦了，只需要负责消费就可以了。此时简单工厂的烧菜方法就让所有客户共用了。（同时这点也是简单工厂方法的缺点——因为工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都会受到影响，也没什么不好理解的，就如事物都有两面性一样道理）

虽然上面已经介绍了简单工厂模式的缺点，下面还是总结下简单工厂模式的缺点：

工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都会受到影响（通俗地意思就是：一旦餐馆没饭或者关门了，很多不愿意做饭的人就没饭吃了）
系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，这样就会造成工厂逻辑过于复杂。

了解了简单工厂模式之后的优缺点之后，我们之后就可以知道简单工厂的应用场景了：

当工厂类负责创建的对象比较少时可以考虑使用简单工厂模式（）
客户如果只知道传入工厂类的参数，对于如何创建对象的逻辑不关心时可以考虑使用简单工厂模式

然后还有什么工厂方法，抽象工厂方法。其实也都是演变下而已。把工厂抽象下

简单工厂模式是类的创建模式，又叫做静态工厂方法模式。就是由一个工厂类根据传入的参量决定创建出哪一种产品类的实例。
一般涉及到三种角色：
工厂类：担任这个角色的是工厂方法模式的核心，含有与应用紧密相关的商业逻辑。工厂类在客户端的直接调用下创建产品对象，
它往往由一个具体的类实现。
抽象产品角色：担任这个角色的类是由工厂方法模式所创建的对象的父类，或她们共同拥有的接口。一般由接口或抽象类实现。
具体产品角色：工厂方法模式所创建的任何对
象都是这个角色的实例，由具体类实现。
简单工厂模式优缺点：
模式的核心是工厂类，这个类负责产品的创建，而客户端可以免去产品创建的责任，这实现了责任的分割。
但由于工厂类集中了所有产品创建逻辑的，如果不能正常工作的话会对系统造成很大的影响。如果增加新产品必须修改工厂角色的源码。

例2

   /// <summary>
    /// 运算类
    /// </summary>
    public abstract class Operation
    {
        public double NumberA { get; set; }
        public double NumberB { get; set; }

        public virtual double GetResult()
        {
            const double result = 0;
            return result;
        }
    }
public class Divide : Operation
    {
        public override double GetResult()
        {
            return NumberA / NumberB;
        }
    }
 /// <summary>
    /// 减法运算
    /// </summary>
    public class Minus : Operation
    {
        public override double GetResult()
        {
            return NumberA - NumberB;
        }
    }
   public class Multiply : Operation
    {
        public override double GetResult()
        {
            return NumberA * NumberB;
        }
    }
  /// <summary>
    /// 加法运算
    /// </summary>
    public class Plus : Operation
    {
        public override double GetResult()
        {
            return NumberA + NumberB;
        }
    }
 public class OperationFactory
    {
        public static Operation CreateOperate(string operate)
        {
            Operation operation = null;

            switch (operate)
            {
                case "+":
                    operation = new Plus();
                    break;
                case "-":
                    operation = new Minus();
                    break;
                case "*":
                    operation = new Multiply();
                    break;
                case "/":
                    operation = new Divide();
                    break;
            }

            return operation;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Operation operateion = OperationFactory.CreateOperate("+");
            operateion.NumberA = 10;
            operateion.NumberB = 5;
            Console.WriteLine(operateion.GetResult());
            Console.ReadKey();
        }
    }

例3:

简单工厂模式的应用以及代码实现

在某个炎热的夏天，我们的学校突然来了一群新伙伴，那就是一批自动售货机，分布在学校的每一个角落，包括我们的五楼电梯口。当你投入硬币取出一瓶冰凉的饮料时，有没有想过我们可以把它写成一个简单工厂模式呢？至少去年的夏天还没有学设计模式的我不会。

当一个人想要喝里面的饮料时，他自己是不会做饮料或者是冰镇的，这说明人这个对象不用自己去创建各种饮料的对象；每个人都有每个人的爱好，来到售货机前，只要投入钱自己点按钮就可以了。这个时候我们就抽象出一些对象的类。例如要买饮料的人就是一个类、各种饮料抽象成为一个饮料类、每种饮料包括（美年达、雪碧、奶咖）之类的就是具体的饮料对象。uml类图如下：

我们首先写这个抽象的类，饮料类

//抽象出的一个父类角色  
public abstract class Drink  
{  
    public abstract string DrinkShow();  
}

接着是一些具体的饮料子类，它们有共同的父类饮料类。有共同的行为和属性。

//具体角色  
    class 美年达:Drink   
    {  
        //获取一瓶美年达  
        public override string DrinkShow()  
        {  
             return "你选择的是美年达";  
        }  
    }  
   class 雪碧:Drink   
   {  
       //获取一瓶雪碧  
       public override string DrinkShow()  
       {  
           return "您选择的是雪碧";  
       }  
   }  
   class 可口可乐:Drink   
   {  
       //获取一瓶可口可乐  
       public override string DrinkShow()  
       {  
           return "您选择的是可口可乐";  
       }  
   }

然后建立一个自动售货机的工厂来出饮料：

//现在建立一个自动售货机工厂类  
  public class DrinkFactory  
  {  
      public static Drink createDrink(string type)  
      {  
          Drink dri=null ;  
          switch (type )  
          {  
              case "美年达":  
                  dri = new 美年达();  
                  break;  
              case "雪碧":  
                  dri = new 雪碧();  
                  break;  
              case "可口可乐":  
                  dri = new 可口可乐();  
                  break;  
          }  
          return dri;  
      }  
  }

最后建立测试客户端，就是主函数main

static void Main(string[] args)  
       {  
           try  
           {  
               //实例化各种饮料  
               Drink 美年达 = DrinkFactory.createDrink("美年达");  
               Drink 雪碧 = DrinkFactory.createDrink("雪碧");  
               Drink 可口可乐 = DrinkFactory.createDrink("可口可乐");  
               //获取饮料  
               if (美年达 != null)  
               {  
                   Console.WriteLine(美年达.DrinkShow());  
               }  
               if (雪碧 != null)  
               {  
                   Console .WriteLine ( 雪碧.DrinkShow());  
               }  
               if (可口可乐 != null)  
               {  
                  Console .WriteLine(可口可乐.DrinkShow());  
               }  
           }  
           catch(Exception ex)  
           {  
               Console.WriteLine("您输入有错：" + ex.Message);  
           }  
       }

三个抽象的产品方法是一样的都是DrinkShow() 区别在于drinkshow 下边实现的内容不一样