c#设计模式- Simple Factory模式（简单工厂）

所有的内容和程序都是按照参考文档自己动手做的

参考

http://www.cnblogs.com/zhenyulu/articles/36462.html

http://wenku.baidu.com/view/2be23625af45b307e871978b.html

一 简单工厂

简单工厂模式是类的创建模式，又叫做静态工厂方法模式。就是由一个工厂类根据传入的参量决定创建出哪一种产品类的实例。

Simple Factory模式根据提供给它的数据，返回几个可能类中的一个类的实例。通常它返回的类都有一个公共的父类和公共的方法。

Simple Factory模式实际上不是GoF 23个设计模式中的一员。

二 简单工厂结构

工厂类：担任这个角色的是工厂方法模式的核心，含有与应用紧密相关的商业逻辑。工厂类在客户端的直接调用下创建产品对象，它往往由一个具体的类实现。

抽象产品角色：担任这个角色的类是由工厂方法模式所创建的对象的父类，或她们共同拥有的接口。一般由接口或抽象类实现。

具体产品角色：工厂方法模式所创建的任何对象都是这个角色的实例，由具体类实现。

三 举例

一个简单工厂的例子

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

namespace FactorySimple
{
    public enum LightType
    {
        Bulb,

        Tube,
    }

    #region Class1
    public abstract class Light
    {
        public abstract void TurnOn();

        public abstract void TurnOff();
    }

    public class BulbLight : Light
    {
        public override void TurnOn()
        {
            Console.WriteLine("BulbLight is turn on");
        }

        public override void TurnOff()
        {
            Console.WriteLine("BulbLight is turn off");
        }
    }

    public class TubeLight : Light
    {
        public override void TurnOn()
        {
            Console.WriteLine("TubeLight is turn on");
        }

        public override void TurnOff()
        {
            Console.WriteLine("TubeLight is turn off");
        }
    }

    public class LightSimpleFactory
    {
        public Light Create(LightType type)
        {
            switch (type)
            {
                case LightType.Bulb:
                    return new BulbLight();
                case LightType.Tube:
                    return new TubeLight();
                default:
                    return null;
            }
        }
    }

    public class Client
    {
        static void Main(string[] args)
        {
            LightSimpleFactory lightFactory = new LightSimpleFactory();
            Light l1 = lightFactory.Create(LightType.Bulb);
            l1.TurnOn();
            l1.TurnOff();

            Console.WriteLine("-----------------------");

            Light l2 = lightFactory.Create(LightType.Tube);
            l2.TurnOn();
            l2.TurnOff();
        }
    }
    #endregion Class1
}

运行结果

1 可以看出 工厂类里面有个create方法，来帮助生成不同的产品。

而客户端调用的时候不用过多的去考虑如何实现的。

2 定义产品的抽象类，所有的产品都继承这个抽象类。

四 简单工厂的改变

除了上面的用法外，在有些情况下Simple Factory可以由抽象产品角色扮演，一个抽象产品类同时是子类的工厂。

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

namespace FactorySimple
{
    public enum LightType
    {
        Bulb,

        Tube,
    }

    #region Class2
    public class Light
    {
        public virtual void TurnOn()
        {
        }

        public virtual void TurnOff()
        {
        }

        public static Light Create(LightType type)
        {
            switch (type)
            {
                case LightType.Bulb:
                    return new BulbLight();
                case LightType.Tube:
                    return new TubeLight();
                default:
                    return null;
            }
        }
    }

    public class BulbLight : Light
    {
        public override void TurnOn()
        {
            Console.WriteLine("Bulb Light is Turned on");
        }

        public override void TurnOff()
        {
            Console.WriteLine("Bulb Light is Turned off");
        }
    }

    public class TubeLight : Light
    {
        public override void TurnOn()
        {
            Console.WriteLine("Tube Light is Turned on");
        }

        public override void TurnOff()
        {
            Console.WriteLine("Tube Light is Turned off");
        }
    }

    public class Client
    {
        public static void Main()
        {
            Light l = Light.Create(LightType.Bulb);
            l.TurnOn();
            l.TurnOff();

            Console.WriteLine("-----------------");

            l = Light.Create(LightType.Tube);
            l.TurnOn();
            l.TurnOff();
        }
    }

    #endregion Class2
}

五 特点

优点：

毕竟是工厂的一种，试用简单逻辑下面的处理。有工厂的判断逻辑，可以叫客户端简单。

缺点：

难以修改和扩展，如果需要增加新的产品类，需要修改工厂类本身。

简单工厂模式通常使用静态工厂方法，这使得无法由子类继承，造成工厂角色无法形成基于继承的等级结构。

个人感觉简单工厂试用开始设计很全面，基本不用扩展的简单程序。试用初期需求可以穷举各种情况。