设计模式 第一回 工厂模型

简单工厂模式

 定义：

专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类或接口。简单工厂模式又称为静态工厂方法（Static Factory Method）模式，属于类的创建型模式，通常根据一个条件（参数）来返回不同的类的实例。

意图：

提供一个类，由它负责根据一定的条件创建某一具体类的实例

参与者：

工厂角色：creater

产品角色：product 产品的抽象。所有产品的父类，描述所有具体产品公用的接口

具体产品：concrete product

实例：
 

 

using System;
using System.Text;

namespace simpleFactory
{
    /// <summary>
    /// requirment:print paper according different type,including email print,document print.factory:printer,product:paper
    /// </summary>
    public interface Iprint
    {
        void GetPaper();
    }
    public class EmailPaper : Iprint
    {
        public void GetPaper()
        {
            Console.WriteLine("this is email paper");
        }
    }
    public class DocumentPaper : Iprint
    {
        public void GetPaper()
        {
            Console.WriteLine("this is document paper");
        }
    }

    public class Printer
    {
        public Iprint CreatePaper(PaperType type)
        {
            switch (type)
            {
                case PaperType.DocumentPaper:
                    return new DocumentPaper();
                case PaperType.EmailPaper:
                    return new EmailPaper();
                default:
                    throw new Exception("not implement");
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Iprint paper;
            Printer printer = new Printer();
            Console.WriteLine("get email paper");
            paper = printer.CreatePaper(PaperType.EmailPaper);
            paper.GetPaper();
            Console.ReadLine();

        }
    }

    public enum PaperType
    {
        DocumentPaper,
        EmailPaper
    }
}

工厂方法：再简单工厂模式的基础上，如果我们不能清晰的明确具体工厂类，为了应对更多可能出现的具体工厂类的产生，需要将具体工厂类进行再次封装。

定义
工厂方法模式又称为工厂模式，也叫虚拟构造器（Virtual Constructor）模式或者多态工厂模式（Polymorphic Factory）,在工厂方法模式中，父类负责定义创建对象的公共接口，而子类则负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成， 即由子类来决定究竟应该实例化（创建）哪一个类。

意图
定义一个用户创建对象的接口，让子类决定实例化哪一个类，工厂方法模式使一个类的实例化延迟到其子类。 

 

 参与者：

 抽象产品角色（Product）定义产品的接口

具体产品角色（ConcreteProduct） 实现接口Product的具体产品类

抽象工厂角色（Creator）  

声明工厂方法（FactoryMethod），返回一个产品  

真实的工厂（ConcreteCreator） 实现FactoryMethod工厂方法，由客户调用，返回一个产品的实例

 

应用情景：

• 类不知道自己要创建哪一个对象时
• 类用它的子类来指定创建哪个对象
• 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候
  

 

实例：

using System;
using System.Reflection;

namespace FactoryMethod
{
    /// <summary>
    /// requirment:print paper according different type,including email print,document print.factory:printer,product:paper
    /// </summary>

    #region product
    public interface Iprint
    {
        void GetPaper();
    }
    #endregion

    #region factory Function
    public interface Ifactory
    {
        Iprint CreatePrinter();
    }
    #endregion

    #region concreate factory
    public class EmailFactory : Ifactory
    {
        public Iprint CreatePrinter()
        {
            return new EmailPaper();
        }

    }

    public class DocumentFactory : Ifactory
    {
        public Iprint CreatePrinter()
        {
            return new DocumentPaper();
        }

    }
    #endregion

    #region concrete product
    public class EmailPaper : Iprint
    {
        public void GetPaper()
        {
            Console.WriteLine("this is email paper");
        }
    }
    public class DocumentPaper : Iprint
    {
        public void GetPaper()
        {
            Console.WriteLine("this is document paper");
        }
    }
    #endregion

   
    class Client
    {
        static void Main(string[] args)
        {
            Console.WriteLine("get email paper");
            Ifactory printer = (Ifactory)Assembly.Load("FactoryMethod").CreateInstance("FactoryMethod.EmailFactory");

            printer.CreatePrinter().GetPaper();
            Console.ReadLine();

        }
    }
}

 

缺点：

• 在添加新产品时，需要编写新的具体产品类（其实这不算一个缺点，因为这是不可避免的），要增加与之对应的具体工厂类。

 

抽象工厂模式：

Abstract Factory模式中，跟客户打交道的只有抽象工厂与抽象产品，客户不需要知道产品由哪个工厂生产，也不需要知道被生产的是哪一种具体的产品。　　

Abstract Factory模式通过抽象工厂为客户（调用者）生成多类产品，抽象工厂负责管理子工厂对象，子工厂负责生成某一类具体的产品对象。

Abstract Factory模式的应用场景：

- 存在多类产品，并需要对这些产品区别对待处理：需要分别为这些产品定义2个以上的接口或抽象类
- 客户端只需要与最上层的工厂（抽象工厂），与最上层的抽象产品打交道 

 

意图：
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

参考者：
也就是该模式中的各个类或对象之间的关系：

• 抽象工厂（Abstract Factory)
  声明生成一系列抽象产品的方法
• 具体工厂（Concrete Factory）
  执行生成一系列抽象产品的方法，生成一系列具体的产品
• 抽象产品（Abstract Product）
  为这一系列的某一种产品声明接口
• 具体产品（Product）
  定义具体工厂生成的具体产品的对象，实现产品接口

 

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

namespace AbstractFactory
{
    public abstract class CarFactory
    {
       
        public abstract AbstractBus CreateBus();
        public abstract AbstractTruck CreateTruck();
        public static CarFactory GetCarFactory(int carType)
        {
            switch (carType)
            {
                case 1:
                    return new BusTruckFactory();
                case 2:
                    return new ModelFactory();
                default: return null;

            }
        }
    }

    public class BusTruckFactory : CarFactory
    {
        public override AbstractBus CreateBus()
        {
            return new Bus();
        }
        public override AbstractTruck CreateTruck()
        {
            return new Truck();
        }

    }

    public class ModelFactory : CarFactory
    {
        public override AbstractBus CreateBus()
        {
            return new ModelBus();
        }
        public override AbstractTruck CreateTruck()
        {
            return new ModelTruck();
        }
    }

    public class AbstractBus
    {
        public string getType()
        {
            return "AbstractBus";
        }
    }
    public class Bus : AbstractBus
    {
        public string getType()
        {
            return "Bus";
        }
    }
    public class ModelBus : AbstractBus
    {
        public string getType()
        {
            return "ModelBus";
        }
    }
    public class AbstractTruck
    {
        public string getType()
        {
            return "AbstractTruck";
        }
    }
    public class Truck :AbstractTruck
    {
          public string getType()
        {
            return "Truck";
        }
    }
    public class ModelTruck : AbstractTruck
    {
        public string getType()
        {
            return "Model Truck";
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            CarFactory factory = CarFactory.GetCarFactory(1);
            Bus bus=(Bus)factory .CreateBus ();
            Console .WriteLine ("create:" +bus.getType ());
            Truck truck=(Truck )factory .CreateTruck ();
            Console .WriteLine ("create:" +truck.getType ());


               factory=CarFactory .GetCarFactory (2);
               ModelBus modelbus = (ModelBus)factory.CreateBus();
               Console.WriteLine("create:" + modelbus.getType());
            ModelTruck modelTruck= (ModelTruck)factory.CreateTruck();
            Console.WriteLine("create:" + modelTruck.getType());
            Console.ReadLine();
        }
    }
}