Factory Method

    
Data & Object Factory
 


training and education for professional developers
 patterns
   C#, ASP.NET, VB.NET, XML, SOAP    

Factory Method

 < back to list of patterns
 definition
 UML diagram
 participants
 sample code in C#


Definition

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.
Frequency of use:  medium high return to top

UML class diagram

return to top



Participants

   The classes and/or objects participating in this pattern are:

  • Product  (Page)
    • defines the interface of objects the factory method creates
  • ConcreteProduct  (SkillsPage, EducationPage, ExperiencePage)
    • implements the Product interface
  • Creator  (Document)
    • declares the factory method, which returns an object of type Product. Creator may also define a default implementation of the factory method that returns a default ConcreteProduct object.
    • may call the factory method to create a Product object.
  • ConcreteCreator  (Report, Resume)
    • overrides the factory method to return an instance of a ConcreteProduct.

return to top




Sample code in C# download C# source code zip file

This structural code demonstrates the Factory method offering great flexibility in creating different objects. The Abstract class may provide a default object, but each subclass can instantiate an extended version of the object.

Hide code

// Factory Method pattern -- Structural example

using System;
using System.Collections;

// "Product"


abstract
class Product

{
}

// "ConcreteProductA"


class
ConcreteProductA : Product

{
}

// "ConcreteProductB"


class
ConcreteProductB : Product

{
}

// "Creator"


abstract
class Creator

{
  // Methods
  abstract public Product FactoryMethod();
}

// "ConcreteCreatorA"


class
ConcreteCreatorA : Creator

{
  // Methods
  override public Product FactoryMethod()
  {
    return new ConcreteProductA();
  }
}

// "ConcreteCreatorB"


class
ConcreteCreatorB : Creator

{
  // Methods
  override public Product FactoryMethod()
  {
    return new ConcreteProductB();
  }
}

///
<summary>

/// Client test
/// </summary>
class Client
{
  public static void Main( string[] args )
  {

   
// FactoryMethod returns ProductA
    Creator c = new ConcreteCreatorA();
    Product p = c.FactoryMethod();
    Console.WriteLine( "Created {0}", p );

   
// FactoryMethod returns ProductB
    c = new ConcreteCreatorB();
    p = c.FactoryMethod();
    Console.WriteLine( "Created {0}", p );  

  }
}

Output
Created ConcreteProductA
Created ConcreteProductB



This real-world code demonstrates the Factory method offering flexibility in creating different documents. The derived Document classes Report and Resume instantiate extended versions of the Document class. Here, the Factory Method is called in the constructor of the Document base class.

Hide code

// Factory Method pattern -- Real World example

using System;
using System.Collections;

// "Product"


abstract
class Page

{
}

// "ConcreteProduct"


class
SkillsPage : Page

{
}

// "ConcreteProduct"


class
EducationPage : Page

{
}

// "ConcreteProduct"


class
ExperiencePage : Page

{
}

// "ConcreteProduct"


class
IntroductionPage : Page

{
}

// "ConcreteProduct"


class
ResultsPage : Page

{
}

// "ConcreteProduct"


class
ConclusionPage : Page

{
}

// "ConcreteProduct"


class
SummaryPage : Page

{
}

// "ConcreteProduct"


class
BibliographyPage : Page

{
}

// "Creator"


abstract
class Document

{
  // Fields
  protected ArrayList pages = new ArrayList();

 
// Constructor
  public Document()
  {
    this.CreatePages();
  }

 
// Properties
  public ArrayList Pages
  {
    get{ return pages; }
  }

 
// Factory Method
  abstract public void CreatePages();
}

// "ConcreteCreator"


class
Resume : Document

{
  // Factory Method implementation
  override public void CreatePages()
  {
    pages.Add( new SkillsPage() );
    pages.Add( new EducationPage() );
    pages.Add( new ExperiencePage() );
  }
}

// "ConcreteCreator"


class
Report : Document

{
  // Factory Method implementation
  override public void CreatePages()
  {
    pages.Add( new IntroductionPage() );
    pages.Add( new ResultsPage() );
    pages.Add( new ConclusionPage() );
    pages.Add( new SummaryPage() );
    pages.Add( new BibliographyPage() );
  }
}

///
<summary>

///  FactoryMethodApp test
/// </summary>
class FactoryMethodApp
{
  public static void Main( string[] args )
  {
    Document[] docs = new Document[ 2 ];

   
// Note: constructors call Factory Method
    docs[0] = new Resume();
    docs[1] = new Report();

   
// Display document pages
    foreach( Document document in docs )
    {
      Console.WriteLine( "\n" + document + " ------- " );
      foreach( Page page in document.Pages )
        Console.WriteLine( " " + page );
    }
  }
}

Output
Resume -------
SkillsPage
EducationPage
ExperiencePage

Report -------
IntroductionPage
ResultsPage
ConclusionPage
SummaryPage
BibliographyPage

return to top




top of document

home | about us | courses | curriculum | schedule | registration | careers | contact us | site map

Copyright © 2002 - Data & Object Factory. All rights reserved. data & object factory™, dofactory.com™, and the 'slanting do' logo are trademarks of Data & Object Factory.

This site has been designed, developed, and is supported by data & object factory.
Terms of use and privacy statement

 

你可能感兴趣的:(factory)