c#设计模式- Factory Method模式（工厂方法）

参考文章

 

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

 

http://wenku.baidu.com/view/e9b3a36a1eb91a37f1115cf2.html

 

代码和内容都是本人亲自测试。

 

一 工厂方法（Factory Method）模式

在软件系统中，由于需求的变化，这个对象的具体实现经常面临着剧烈的变化，但它却有比较稳定的接口。

 

定义一个用户创建对象的接口，让子类决定实例哪一个类。Factory Method使一个类的实例化延迟到子类。

 

在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不接触哪一个产品类被实例化这种细节。这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。
 
在Factory Method模式中，工厂类与产品类往往具有平行的等级结构，它们之间一一对应。

 

二 工厂方法模式的角色

抽象工厂（Creator）角色：是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
 
具体工厂（Concrete Creator）角色：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。在上图中有两个这样的角色：BulbCreator与TubeCreator。
 
抽象产品（Product）角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。在上图中，这个角色是Light。
 
具体产品（Concrete Product）角色：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。

 

 三 一个例子

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

namespace FactoryMethod
{
    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 abstract class Creator
    {
        public abstract Light factory();
    }

    public class BulbCreator : Creator
    {
        public override Light factory()
        {
            return new BulbLight();
        }
    }

    public class TubeCreator : Creator
    {
        public override Light factory()
        {
            return new TubeLight();
        }
    }

    public class Client
    {
        static void Main(string[] args)
        {
            Creator c1 = new BulbCreator();
            Creator c2 = new TubeCreator();

            Light l1 = c1.factory();

            l1.TurnOn();
            l1.TurnOff();

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

            l1 = c2.factory(); 
            l1.TurnOn();
            l1.TurnOff();
        }
    }
}

可以跟简单工厂进行比较

1 工厂类也定义一个基本的抽象类，不实现逻辑和实例化。

2 不同产品有自己的不同的工厂类来实现。在调用的时候用不同类的相同工厂方法创建实例。

 

四 工厂方法模式与简单工厂模式

工厂方法模式与简单工厂模式再结构上的不同不是很明显。工厂方法类的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。

工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂类都有共同的接口，或者有共同的抽象父类。

当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合了"开放－封闭"原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。

工厂方法模式退化后可以演变成简单工厂模式。

 

五 另外一个例子

 

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

namespace FactoryMethod2
{

    abstract class Page
    {
    }

    class SkillsPage : Page
    {
    }

    class EducationPage : Page
    {
    }

    class ExperiencePage : Page
    {
    }

    class IntroductionPage : Page
    {
    }

    class ResultPage : Page
    {
    }

    class ConclusionPage : Page
    {
    }

    class SummaryPage : Page
    {
    }

    class BibliographyPage : Page
    {
    }

    abstract class Document
    {
        protected ArrayList pages = new ArrayList();

        public Document()
        {
            this.CreatPages();
        }

        public ArrayList Pages
        {
            get { return pages; }
        }

        abstract public void CreatPages();
    }

    class Resume : Document
    {
        public override void CreatPages()
        {
            pages.Add(new SkillsPage());
            pages.Add(new EducationPage());
            pages.Add(new ExperiencePage());
        }
    }

    class Report : Document
    {
        public override void CreatPages()
        {
            pages.Add(new IntroductionPage());
            pages.Add(new ResultPage());
            pages.Add(new ConclusionPage());
            pages.Add(new SummaryPage());
            pages.Add(new BibliographyPage());
        }
    }

    class Client
    {
        static void Main(string[] args)
        {
            Document[] docs = new Document[2];

            docs[0]= new Resume();
            docs[1] = new Report();

            foreach (Document temp in docs)
            {
                Console.WriteLine(" " + temp + " ------- ");
                foreach (Page page in temp.Pages)
                {
                    Console.WriteLine(" " + page);
                }
                Console.WriteLine("");
            }
        }
    }
}

第二个例子比第一个例子更加的直观。

 

Factory Method模式主要用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型，紧耦合关系会导致软件的脆弱。

Factory Method模式通过面向对象的手法，将所要创建的具体对象工作延迟到子类，从而实现一种扩展（而非更改）的策略，较好地解决了这种紧耦合关系。