IT博客-毒菇求Buy-文章分类-Design Pattern

GOF pattern - Bridge

毒菇求Buy — Thu, 07 Jul 2005 00:58:00 GMT

Definition

Decouple an abstraction from its implementation so that the two can vary independently.

Frequency of use: medium

UML class diagram

Participants

Abstraction (BusinessObject)
- defines the abstraction's interface.
- maintains a reference to an object of type Implementor.
RefinedAbstraction (CustomersBusinessObject)
- extends the interface defined by Abstraction.
Implementor (DataObject)
- defines the interface for implementation classes. This interface doesn't have to correspond exactly to Abstraction's interface; in fact the two interfaces can be quite different. Typically the Implementation interface provides only primitive operations, and Abstraction defines higher-level operations based on these primitives.
ConcreteImplementor (CustomersDataObject)
- implements the Implementor interface and defines its concrete implementation.

Sample code

This structural code demonstrates the Bridge pattern which separates (decouples) the interface from its implementation. The implementation can evolve without changing clients which use the abstraction of the object.

// Bridge pattern -- Structural example

//--------------------------------------------------------
// Copyright (C) 2001 - 2002, Data & Object Factory
// All rights reserved. www.dofactory.com
//
// You are free to use this source code in your
// applications as long as the original copyright
// notice is included.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT
// WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//--------------------------------------------------------

using System;

// "Abstraction"
class Abstraction {
  // Fields
  protected Implementor implementor;

  // Properties
  public Implementor Implementor {
    set{ implementor = value; }
  }

  // Methods
  virtual public void Operation() {
    implementor.Operation();
  }
}

// "Implementor"
abstract class Implementor {
  // Methods
  abstract public void Operation();
}

// "RefinedAbstraction"
class RefinedAbstraction : Abstraction {
  // Methods
  override public void Operation() {
    implementor.Operation();
  }
}

// "ConcreteImplementorA"

class ConcreteImplementorA : Implementor {
  // Methods
  override public void Operation() {
    Console.WriteLine("ConcreteImplementorA Operation");
  }
}

// "ConcreteImplementorB"
class ConcreteImplementorB : Implementor {
  // Methods
  override public void Operation() {
    Console.WriteLine("ConcreteImplementorB Operation");
  }
}

///

/// Client test
///

public class Client {
  public static void Main( string[] args ) {
    Abstraction abstraction = new RefinedAbstraction();

    // Set implementation and call
    abstraction.Implementor = new ConcreteImplementorA();
    abstraction.Operation();

    // Change implemention and call
    abstraction.Implementor = new ConcreteImplementorB();
    abstraction.Operation();
  }
}

This real-world code demonstrates the Bridge pattern in which a BusinessObject abstraction is decoupled from the implementation in DataObject. The DataObject implementations can evolve dynamically without changing any clients.

// Bridge pattern -- Real World example

//--------------------------------------------------------
// Copyright (C) 2001 - 2002, Data & Object Factory
// All rights reserved. www.dofactory.com
//
// You are free to use this source code in your
// applications as long as the original copyright
// notice is included.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT
// WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//--------------------------------------------------------

using System;
using System.Collections;

// "Abstraction"
class BusinessObject {
  // Fields
  private DataObject dataObject;
  protected string group;

  // Constructors
  public BusinessObject( string group ) {
    this.group = group;
  }

  // Properties
  public DataObject DataObject {
    set{ dataObject = value; }
    get{ return dataObject; }
  }

  // Methods
  virtual public void Next() {
    dataObject.NextRecord();
  }

  virtual public void Prior() {
    dataObject.PriorRecord();
  }

  virtual public void New( string name ) {
    dataObject.NewRecord( name );
  }

  virtual public void Delete( string name ) {
    dataObject.DeleteRecord( name );
  }

  virtual public void Show() {
    dataObject.ShowRecord();
  }

  virtual public void ShowAll() {
    Console.WriteLine( "Customer Group: {0}", group );
    dataObject.ShowAllRecords();
  }
}

// "RefinedAbstraction"

class CustomersBusinessObject : BusinessObject {
  // Constructors
  public CustomersBusinessObject( string group )
    : base( group ){}

  // Methods
  override public void ShowAll() {
    // Add separator lines
    Console.WriteLine();
    Console.WriteLine( "------------------------" );
    base.ShowAll();
    Console.WriteLine( "------------------------" );
  }
}

// "Implementor"
abstract class DataObject {
  // Methods
  abstract public void NextRecord();
  abstract public void PriorRecord();
  abstract public void NewRecord( string name );
  abstract public void DeleteRecord( string name );
  abstract public void ShowRecord();
  abstract public void ShowAllRecords();
}

// "ConcreteImplementor"
class CustomersDataObject : DataObject {
  // Fields
  private ArrayList customers = new ArrayList();
  private int current = 0;

  // Constructors
  public CustomersDataObject() {
    // Loaded from a database
    customers.Add( "Jim Jones" );
    customers.Add( "Samual Jackson" );
    customers.Add( "Allen Good" );
    customers.Add( "Ann Stills" );
    customers.Add( "Lisa Giolani" );
  }

  // Methods
  public override void NextRecord() {
    if( current <= customers.Count - 1 )
      current++;
  }

  public override void PriorRecord() {
    if( current > 0 )
      current--;
  }

  public override void NewRecord( string name ) {
    customers.Add( name );
  }

  public override void DeleteRecord( string name ) {
    customers.Remove( name );
  }

  public override void ShowRecord() {
    Console.WriteLine( customers[ current ] );
  }

  public override void ShowAllRecords() {
    foreach( string name in customers )
      Console.WriteLine( " " + name );
  }
}

///

/// Client test
///

public class BusinessApp {
  public static void Main( string[] args ) {
    // Create RefinedAbstraction
    CustomersBusinessObject customers =
      new CustomersBusinessObject(" Chicago ");

    // Set ConcreteImplementor
    customers.DataObject = new CustomersDataObject();

    // Exercise the bridge
    customers.Show();
    customers.Next();
    customers.Show();
    customers.Next();
    customers.Show();
    customers.New( "Henry Velasquez" );

    customers.ShowAll();
  }
}

毒菇求Buy 2005-07-07 08:58 发表评论

GOF pattern - Adapter

毒菇求Buy — Thu, 07 Jul 2005 00:49:00 GMT

Definition

Convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.

Frequency of use: medium high

UML class diagram

Participants

The classes and/or objects participating in the Adapter pattern are:

Target (ChemicalCompound)
- defines the domain-specific interface that Client uses.
Adapter (Compound)
- adapts the interface Adaptee to the Target interface.
Adaptee (ChemicalDatabank)
- defines an existing interface that needs adapting.
Client (AdapterApp)
- collaborates with objects conforming to the Target interface.

Sample code

This structural code demonstrates the Adapter pattern which maps the interface of one class onto another so that they can work together. These incompatible classes may come from different libraries or frameworks.

// Adapter pattern -- Structure example

//--------------------------------------------------------
// Copyright (C) 2001 - 2002, Data & Object Factory
// All rights reserved. www.dofactory.com
//
// You are free to use this source code in your
// applications as long as the original copyright
// notice is included.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT
// WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//--------------------------------------------------------

using System;

// "Target"
class Target {
  // Methods
  virtual public void Request() {
    // Normal implementation goes here
  }
}

// "Adapter"
class Adapter : Target {
  // Fields
  private Adaptee adaptee = new Adaptee();

  // Methods
  override public void Request() {
    // Possibly do some data manipulation
    //   and then call SpecificRequest
    adaptee.SpecificRequest();
  }
}

// "Adaptee"
class Adaptee {
  // Methods
  public void SpecificRequest() {
    Console.WriteLine("Called SpecificRequest()" );
  }
}

///

/// Client test
///

public class Client {
  public static void Main(string[] args) {
    // Create adapter and place a request
    Target t = new Adapter();
    t.Request();
  }
}

This real-world code demonstrates the use of a legacy chemical databank. Chemical compound objects access the databank through an Adapter interface.

// Adapter pattern -- Real World example

//--------------------------------------------------------
// Copyright (C) 2001 - 2002, Data & Object Factory
// All rights reserved. www.dofactory.com
//
// You are free to use this source code in your
// applications as long as the original copyright
// notice is included.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT
// WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//--------------------------------------------------------

using System;

// "Target"
class ChemicalCompound {
  // Fields
  protected string name;
  protected float boilingPoint;
  protected float meltingPoint;
  protected double molecularWeight;
  protected string molecularFormula;

  // Constructors
  public ChemicalCompound( string name ) {
    this.name = name;
  }

  // Properties
  public float BoilingPoint {
    get{ return boilingPoint; }
  }

  public float MeltingPoint {
    get{ return meltingPoint;  }
  }

  public double MolecularWeight {
    get{ return molecularWeight; }
  }

  public string MolecularFormula {
    get{ return molecularFormula; }
  }
}

// "Adapter"
class Compound : ChemicalCompound {
  // Fields
  private ChemicalDatabank bank;

  // Constructors
  public Compound( string name ) : base( name ) {
    // Adaptee
    bank = new ChemicalDatabank();

    // Adaptee request methods
    boilingPoint = bank.GetCriticalPoint( name, "B" );
    meltingPoint = bank.GetCriticalPoint( name, "M" );
    molecularWeight = bank.GetMolecularWeight( name );
    molecularFormula = bank.GetMolecularStructure( name );
  }

  // Methods
  public void Display() {
    Console.WriteLine("\nCompound: {0} ------ ",name );
    Console.WriteLine(" Formula: {0}",MolecularFormula);
    Console.WriteLine(" Weight : {0}",MolecularWeight );
    Console.WriteLine(" Melting Pt: {0}",MeltingPoint );
    Console.WriteLine(" Boiling Pt: {0}",BoilingPoint );
  }
}

// "Adaptee"
class ChemicalDatabank {
  // Methods -- the Databank 'legacy API'
  public float GetCriticalPoint( string compound, string point ) {
    float temperature = 0.0F;

    // Melting Point
    if( point == "M" ) {
      switch( compound.ToLower() ) {
        case "water": temperature = 0.0F;break;
        case "benzene" : temperature = 5.5F; break;
        case "alcohol": temperature = -114.1F; break;
      }
    } else {  // Boiling Point
      switch( compound.ToLower() ) {
        case "water": temperature = 100.0F;break;
        case "benzene" : temperature = 80.1F; break;
        case "alcohol": temperature = 78.3F; break;
      }
    }
    return temperature;
  }

  public string GetMolecularStructure( string compound ) {
    string structure = "";

    switch( compound.ToLower() ) {
      case "water": structure = "H20"; break;
      case "benzene" : structure = "C6H6"; break;
      case "alcohol": structure = "C2H6O2"; break;
    }
    return structure;
  }

  public double GetMolecularWeight( string compound ) {
    double weight = 0.0;
    switch( compound.ToLower() ) {
      case "water": weight = 18.015; break;
      case "benzene" : weight = 78.1134; break;
      case "alcohol": weight = 46.0688; break;
    }
    return weight;
  }
}

///

/// AdapterApp test application
///

public class AdapterApp {
  public static void Main(string[] args) {
    // Retrieve and display water characteristics
    Compound water = new Compound( "Water" );
    water.Display();

    // Retrieve and display benzene characteristics
    Compound benzene = new Compound( "Benzene" );
    benzene.Display();

    // Retrieve and display alcohol characteristics
    Compound alcohol = new Compound( "Alcohol" );
    alcohol.Display();

    Console.Read();
  }
}

毒菇求Buy 2005-07-07 08:49 发表评论

GOF pattern - Singleton

毒菇求Buy — Thu, 07 Jul 2005 00:38:00 GMT

Definition

Ensure a class has only one instance and provide a global point of access to it.

Frequency of use: high

UML class diagram

Participants

The classes and/or objects participating in the Singleton pattern are:

Singleton (LoadBalancer)
- defines an Instance operation that lets clients access its unique instance. Instance is a class operation.
- responsible for creating and maintaining its own unique instance.

Sample code

This structural code demonstrates the Singleton pattern which assures only a single instance (the singleton) of the class can be created.

// Singleton pattern -- Structural example

//--------------------------------------------------------
// Copyright (C) 2001 - 2002, Data & Object Factory
// All rights reserved. www.dofactory.com
//
// You are free to use this source code in your
// applications as long as the original copyright
// notice is included.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT
// WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//--------------------------------------------------------

using System;

// "Singleton"
class Singleton {
  // Fields
  private static Singleton instance;

  // Constructor
  protected Singleton() {}

  // Methods
  public static Singleton Instance() {
    // Uses "Lazy initialization"
    if( instance == null )
      instance = new Singleton();

    return instance;
  }
}

///

/// Client test
///

public class Client {
  public static void Main() {
    // Constructor is protected -- cannot use new
    Singleton s1 = Singleton.Instance();
    Singleton s2 = Singleton.Instance();

    if( s1 == s2 )
      Console.WriteLine( "The same instance" );

    Console.Read();
  }
}

A .NET specificed implementation:

sealed class Singleton {
private Singleton();

public static readonly Singleton Instance = new Singleton();
}

This real-world code demonstrates the Singleton pattern as a LoadBalancing object. Only a single instance (the singleton) of the class can be created because servers may dynamically come on- or off-line and every request must go throught the one object that has knowledge about the state of the (web) farm.

// Singleton pattern

//--------------------------------------------------
// Copyright (C) 2001, Data & Object Factory
// All rights reserved. www.dofactory.com
//
// You are free to use this source code in your
// applications, although it is intended only for
// educational purposes.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS"
// WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR
// FITNESS FOR A PARTICULAR PURPOSE.
//--------------------------------------------------

using System;
using System.Collections;
using System.Threading;

// "Singleton"
class LoadBalancer {
  // Fields
  private static LoadBalancer balancer;
  private ArrayList servers = new ArrayList();
  private Random random = new Random();

  // Constructors (protected)
  protected LoadBalancer() {
    // List of available servers
    servers.Add( "ServerI" );
    servers.Add( "ServerII" );
    servers.Add( "ServerIII" );
    servers.Add( "ServerIV" );
    servers.Add( "ServerV" );
  }

  // Methods
  public static LoadBalancer GetLoadBalancer() {
    // Support multithreaded applications through
    // "Double checked locking" pattern which avoids
    // locking every time the method is invoked
    if( balancer == null ) {
      // Only one thread can obtain a mutex
      Mutex mutex = new Mutex();
      mutex.WaitOne();

      if( balancer == null )
        balancer = new LoadBalancer();

      mutex.Close();
    }

    return balancer;
  }

  // Properties
  public string Server {
    get
    {
      // Simple, but effective random load balancer
      int r = random.Next( servers.Count );
      return servers[ r ].ToString();
    }
  }
}

///

/// SingletonApp test
///

///
public class SingletonApp {
  public static void Main( string[] args ) {
    LoadBalancer b1 = LoadBalancer.GetLoadBalancer();
    LoadBalancer b2 = LoadBalancer.GetLoadBalancer();
    LoadBalancer b3 = LoadBalancer.GetLoadBalancer();
    LoadBalancer b4 = LoadBalancer.GetLoadBalancer();

    // Same instance?
    if( (b1 == b2) && (b2 == b3) && (b3 == b4) )
      Console.WriteLine( "Same instance" );

    // Do the load balancing
    Console.WriteLine( b1.Server );
    Console.WriteLine( b2.Server );
    Console.WriteLine( b3.Server );
    Console.WriteLine( b4.Server );

    Console.Read();
  }
}

毒菇求Buy 2005-07-07 08:38 发表评论

GOF pattern - Prototype

毒菇求Buy — Thu, 07 Jul 2005 00:19:00 GMT

Definition

Specify the kind of objects to create using a prototypical instance, and create new objects by copying this prototype.

Frequency of use: medium low

UML class diagram

Participants

The classes and/or objects participating in the Prototype pattern are:

Prototype (ColorPrototype)
- declares an interace for cloning itself
ConcretePrototype (Color)
- implements an operation for cloning itself
Client (ColorManager)
- creates a new object by asking a prototype to clone itself

Sample code

This structural code demonstrates the Prototype pattern in which new objects are created by copying pre-existing objects (prototypes) of the same class.

// Prototype pattern -- Structural example

//--------------------------------------------------------
// Copyright (C) 2001 - 2002, Data & Object Factory
// All rights reserved. www.dofactory.com
//
// You are free to use this source code in your
// applications as long as the original copyright
// notice is included.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT
// WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//--------------------------------------------------------

using System;

// "Prototype"
abstract class Prototype {
  // Fields
  private string id;

  // Constructors
  public Prototype( string id ) {
    this.id = id;
  }

  public string Id {
    get{ return id; }
  }

  // Methods
  abstract public Prototype Clone();
}

// "ConcretePrototype1"
class ConcretePrototype1 : Prototype {
  // Constructors
  public ConcretePrototype1( string id ) : base ( id ) {}

  // Methods
  override public Prototype Clone() {
    // Shallow copy
    return (Prototype)this.MemberwiseClone();
  }
}

// "ConcretePrototype2"
class ConcretePrototype2 : Prototype {
  // Constructors
  public ConcretePrototype2( string id ) : base ( id ) {}

  // Methods
  override public Prototype Clone() {
    // Shallow copy
    return (Prototype)this.MemberwiseClone();
  }
}

///

/// Client test
///

class Client {
  public static void Main( string[] args ) {
    // Create two instances and clone each
    ConcretePrototype1 p1 = new ConcretePrototype1("I");
    ConcretePrototype1 c1 = (ConcretePrototype1)p1.Clone();
    Console.WriteLine( "Cloned: {0}", c1.Id );

    ConcretePrototype2 p2 = new ConcretePrototype2("II");
    ConcretePrototype2 c2 = (ConcretePrototype2)p2.Clone();
    Console.WriteLine( "Cloned: {0}", c2.Id );
  }
}

This real-world code demonstrates the Prototype pattern in which new Color objects are created by copying pre-existing, user-defined Colors of the same type.

// Prototype pattern -- Real World example

//--------------------------------------------------------
// Copyright (C) 2001 - 2002, Data & Object Factory
// All rights reserved. www.dofactory.com
//
// You are free to use this source code in your
// applications as long as the original copyright
// notice is included.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT
// WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//--------------------------------------------------------

using System;
using System.Collections;

// "Prototype"
abstract class ColorPrototype {
  // Methods
  public abstract ColorPrototype Clone();
}

// "ConcretePrototype"
class Color : ColorPrototype {
  // Fields
  private int red, green, blue;

  // Constructors
  public Color( int red, int green, int blue) {
    this.red = red;
    this.green = green;
    this.blue = blue;
  }

  // Methods
  public override ColorPrototype Clone() {
    // Creates a 'shallow copy'
    return (ColorPrototype) this.MemberwiseClone();
  }

  public void Display() {
    Console.WriteLine( "RGB values are: {0},{1},{2}",
                                     red, green, blue );
  }
}

// Prototype manager
class ColorManager {
  // Fields
  Hashtable colors = new Hashtable();

  // Indexers
  public ColorPrototype this[ string name ] {
    get{ return (ColorPrototype)colors[ name ]; }
    set{ colors.Add( name, value ); }
  }
}

///

/// PrototypeApp test
///

class PrototypeApp {
  public static void Main( string[] args ) {
    ColorManager colormanager = new ColorManager();

    // Initialize with standard colors
    colormanager[ "red" ] = new Color( 255, 0, 0 );
    colormanager[ "green" ] = new Color( 0, 255, 0 );
    colormanager[ "blue" ] = new Color( 0, 0, 255 );

    // User adds personalized colors
    colormanager[ "angry" ] = new Color( 255, 54, 0 );
    colormanager[ "peace" ] = new Color( 128, 211, 128 );
    colormanager[ "flame" ] = new Color( 211, 34, 20 );

    // User uses selected colors
    string colorName = "red";
    Color c1 = (Color)colormanager[ colorName ].Clone();
    c1.Display();

    colorName = "peace";
    Color c2 = (Color)colormanager[ colorName ].Clone();
    c2.Display();

    colorName = "flame";
    Color c3 = (Color)colormanager[ colorName ].Clone();
    c3.Display();

    Console.Read();
  }
}

毒菇求Buy 2005-07-07 08:19 发表评论

GOF pattern - Factory Method

毒菇求Buy — Wed, 06 Jul 2005 02:18:00 GMT

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

UML class diagram

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.

Sample code

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.

// Factory Method pattern -- Structural example

//--------------------------------------------------------
// Copyright (C) 2001 - 2002, Data & Object Factory
// All rights reserved. www.dofactory.com
//
// You are free to use this source code in your
// applications as long as the original copyright
// notice is included.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT
// WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//--------------------------------------------------------

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();
}

// "ConcreteCreator"
class ConcreteCreatorA : Creator {
  // Methods
  override public Product FactoryMethod() {
    return new ConcreteProductA();
  }
}

// "ConcreteCreator"
class ConcreteCreatorB : Creator {
  // Methods
  override public Product FactoryMethod() {
    return new ConcreteProductB();
  }
}

///

/// Client test
///

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 );
  }
}

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.

// Factory Method pattern -- Real World example

//--------------------------------------------------------
// Copyright (C) 2001 - 2002, Data & Object Factory
// All rights reserved. www.dofactory.com
//
// You are free to use this source code in your
// applications as long as the original copyright
// notice is included.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT
// WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//--------------------------------------------------------

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() );
  }
}

///

/// FactoryMethodApp test
///

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 );
    }

    Console.Read();
  }
}

毒菇求Buy 2005-07-06 10:18 发表评论

GOF pattern - Builder

毒菇求Buy — Wed, 06 Jul 2005 00:53:00 GMT

Definition

Separate the construction of a complex object from its representation so that the same construction process can create different representations.

Frequency of use: medium

UML class diagram

Participants

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

Builder (VehicleBuilder)
- specifies an abstract interface for creating parts of a Product object
ConcreteBuilder (MotorCycleBuilder, CarBuilder, ScooterBuilder)
- constructs and assembles parts of the product by implementing the Builder interface
- defines and keeps track of the representation it creates
- provides an interface for retrieving the product
Director (Shop)
- constructs an object using the Builder interface
Product (Vehicle)
- represents the complex object under construction. ConcreteBuilder builds the product's internal representation and defines the process by which it's assembled
- includes classes that define the constituent parts, including interfaces for assembling the parts into the final result

Sample code

This structural code demonstrates the Builder pattern in which complex objects are created in a step-by-step fashion. The construction process can create different object representations and provides a high level of control over the assembly of the objects.

// Builder pattern -- Structure example

//--------------------------------------------------------
// Copyright (C) 2001 - 2002, Data & Object Factory
// All rights reserved. www.dofactory.com
//
// You are free to use this source code in your
// applications as long as the original copyright
// notice is included.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT
// WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//--------------------------------------------------------

using System;
using System.Collections;

// "Director"
class Director {
  // Methods
  public void Construct( Builder builder ) {
    builder.BuildPartA();
    builder.BuildPartB();
  }
}

// "Builder"
abstract class Builder {
  // Methods
  abstract public void BuildPartA();
  abstract public void BuildPartB();
  abstract public Product GetResult();
}

// "ConcreteBuilder1"
class ConcreteBuilder1 : Builder {
  // Fields
  private Product product;

  // Methods
  override public void BuildPartA() {
    product = new Product();
    product.Add( "PartA" );
  }

  override public void BuildPartB() {
    product.Add( "PartB" );
  }

  override public Product GetResult() {
    return product;
  }
}
// "ConcreteBuilder2"
class ConcreteBuilder2 : Builder {
  // Fields
  private Product product;

  // Methods
  override public void BuildPartA() {
    product = new Product();
    product.Add( "PartX" );
  }

  override public void BuildPartB() {
    product.Add( "PartY" );
  }

  override public Product GetResult() {
    return product;
  }
}

// "Product"
class Product {
  // Fields
  ArrayList parts = new ArrayList();

  // Methods
  public void Add( string part ) {
    parts.Add( part );
  }

  public void Show() {
    Console.WriteLine( "\nProduct Parts -------" );
    foreach( string part in parts )
      Console.WriteLine( part );
  }
}

///

/// Client test
///

public class Client {
  public static void Main( string[] args ) {
    // Create director and builders
    Director director = new Director( );

    Builder b1 = new ConcreteBuilder1();
    Builder b2 = new ConcreteBuilder2();

    // Construct two products
    director.Construct( b1 );
    Product p1 = b1.GetResult();
    p1.Show();

    director.Construct( b2 );
    Product p2 = b2.GetResult();
    p2.Show();
  }
}

This real-world code demonstates the Builder pattern in which different vehicles are assembled in a step-by-step fashion. The Shop uses VehicleBuilders to construct a variety of Vehicles in a series of sequential steps.

// Builder pattern -- Real World example

//--------------------------------------------------------
// Copyright (C) 2001 - 2002, Data & Object Factory
// All rights reserved. www.dofactory.com
//
// You are free to use this source code in your
// applications as long as the original copyright
// notice is included.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT
// WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//--------------------------------------------------------

using System;
using System.Collections;

// "Director"
class Shop {
  // Methods
  public void Construct( VehicleBuilder vehicleBuilder ) {
    vehicleBuilder.BuildFrame();
    vehicleBuilder.BuildEngine();
    vehicleBuilder.BuildWheels();
    vehicleBuilder.BuildDoors();
  }
}

// "Builder"
abstract class VehicleBuilder {
  // Fields
  protected Vehicle vehicle;

  // Properties
  public Vehicle Vehicle {
    get{ return vehicle; }
  }

  // Methods
  abstract public void BuildFrame();
  abstract public void BuildEngine();
  abstract public void BuildWheels();
  abstract public void BuildDoors();
}

// "ConcreteBuilder1"
class MotorCycleBuilder : VehicleBuilder {
  // Methods
  override public void BuildFrame() {
    vehicle = new Vehicle( "MotorCycle" );
    vehicle[ "frame" ] = "MotorCycle Frame";
  }

  override public void BuildEngine() {
    vehicle[ "engine" ] = "500 cc";
  }

  override public void BuildWheels() {
    vehicle[ "wheels" ] = "2";
  }

  override public void BuildDoors() {
    vehicle[ "doors" ] = "0";
  }
}

// "ConcreteBuilder2"
class CarBuilder : VehicleBuilder {
  // Methods
  override public void BuildFrame() {
    vehicle = new Vehicle( "Car" );
    vehicle[ "frame" ] = "Car Frame";
  }

  override public void BuildEngine() {
    vehicle[ "engine" ] = "2500 cc";
  }

  override public void BuildWheels() {
    vehicle[ "wheels" ] = "4";
  }

  override public void BuildDoors() {
    vehicle[ "doors" ] = "4";
  }
}

// "ConcreteBuilder3"
class ScooterBuilder : VehicleBuilder {
  // Methods
  override public void BuildFrame() {
    vehicle = new Vehicle( "Scooter" );
    vehicle[ "frame" ] = "Scooter Frame";
  }

  override public void BuildEngine() {
    vehicle[ "engine" ] = "none";
  }

  override public void BuildWheels() {
    vehicle[ "wheels" ] = "2";
  }

  override public void BuildDoors() {
    vehicle[ "doors" ] = "0";
  }
}

// "Product"
class Vehicle {
  // Fields
  private string type;
  private Hashtable parts = new Hashtable();

  // Constructors
  public Vehicle( string type ) {
    this.type = type;
  }

  // Indexers
  public object this[ string key ] {
    get{ return parts[ key ]; }
    set{ parts[ key ] = value; }
  }

  // Methods
  public void Show() {
    Console.WriteLine( "\n---------------------------");
    Console.WriteLine( "Vehicle Type: {0}", type );
    Console.WriteLine( " Frame  : {0}", parts[ "frame" ] );
    Console.WriteLine( " Engine : {0}", parts[ "engine" ] );
    Console.WriteLine( " #Wheels: {0}", parts[ "wheels" ] );
    Console.WriteLine( " #Doors : {0}", parts[ "doors" ] );
  }
}

///

/// BuilderApp test
///

public class BuilderApp {
  public static void Main( string[] args ) {
    // Create shop with vehicle builders
    Shop shop = new Shop();
    VehicleBuilder b1 = new ScooterBuilder();
    VehicleBuilder b2 = new CarBuilder();
    VehicleBuilder b3 = new MotorCycleBuilder();

    // Construct and display vehicles
    shop.Construct( b1 );
    b1.Vehicle.Show();

    shop.Construct( b2 );
    b2.Vehicle.Show();

    shop.Construct( b3 );
    b3.Vehicle.Show();
  }
}

毒菇求Buy 2005-07-06 08:53 发表评论

GOF pattern - Abstract Factory

毒菇求Buy — Wed, 06 Jul 2005 00:39:00 GMT

Abstract Factory

Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

Frequency of use: medium high

UML class diagram

Participants

AbstractFactory (ContinentFactory)
- declares an interface for operations that create abstract products
ConcreteFactory (AfricaFactory, AmericaFactory)
- implements the operations to create concrete product objects
AbstractProduct (Herbivore, Carnivore)
- declares an interface for a type of product object
Product (Wildebeest, Lion, Bison, Wolf)
- defines a product object to be created by the corresponding concrete factory
- implements the AbstractProduct interface
Client (AnimalWorld)
- uses interfaces declared by AbstractFactory and AbstractProduct classes

Sample code

This structural code demonstrates the Abstract Factory pattern creating parallel hierarchies of objects. Object creation has been abstracted and there is no need for hard-coded class names in the client code.

// Abstract Factory pattern -- Structural example

//--------------------------------------------------------
// Copyright (C) 2001 - 2002, Data & Object Factory
// All rights reserved. www.dofactory.com
//
// You are free to use this source code in your
// applications as long as the original copyright
// notice is included.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT
// WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//--------------------------------------------------------

using System;

// "AbstractFactory"
abstract class AbstractFactory {
  // Methods
  abstract public AbstractProductA CreateProductA();
  abstract public AbstractProductB CreateProductB();
}

// "ConcreteFactory1"
class ConcreteFactory1 : AbstractFactory {
  // Methods
  override public AbstractProductA CreateProductA() {
    return new ProductA1();
  }
  override public AbstractProductB CreateProductB() {
    return new ProductB1();
  }
}

// "ConcreteFactory2"
class ConcreteFactory2 : AbstractFactory {
  // Methods
  override public AbstractProductA CreateProductA() {
    return new ProductA2();
  }
  override public AbstractProductB CreateProductB() {
    return new ProductB2();
  }
}

// "AbstractProductA"

abstract class AbstractProductA {
}

// "AbstractProductB"
abstract class AbstractProductB {
  // Methods
  abstract public void Interact( AbstractProductA a );
}

// "ProductA1"
class ProductA1 : AbstractProductA {
}

// "ProductB1"
class ProductB1 : AbstractProductB {
  // Methods
  override public void Interact( AbstractProductA a ) {
    Console.WriteLine( this + " interacts with " + a );
  }
}

// "ProductA2"
class ProductA2 : AbstractProductA {
}

// "ProductB2"
class ProductB2 : AbstractProductB {
  // Methods
  override public void Interact( AbstractProductA a ) {
    Console.WriteLine( this + " interacts with " + a );
  }
}

// "Client" - the interaction environment of the products
class Environment {
  // Fields
  private AbstractProductA AbstractProductA;
  private AbstractProductB AbstractProductB;

  // Constructors
  public Environment( AbstractFactory factory ) {
    AbstractProductB = factory.CreateProductB();
    AbstractProductA = factory.CreateProductA();
  }

  // Methods
  public void Run() {
    AbstractProductB.Interact( AbstractProductA );
  }
}

///

/// ClientApp test environment
///

class ClientApp {
  public static void Main(string[] args) {
    AbstractFactory factory1 = new ConcreteFactory1();
    Environment e1 = new Environment( factory1 );
    e1.Run();

    AbstractFactory factory2 = new ConcreteFactory2();
    Environment e2 = new Environment( factory2 );
    e2.Run();

    Console.Read();
  }
}

This real-world code demonstrates the creation of different animal worlds for a computer game using different factories. Although the animals created by the Continent factories are different, the interactions among the animals remain the same.

// Abstract Factory pattern -- Real World example

//--------------------------------------------------------
// Copyright (C) 2001 - 2002, Data & Object Factory
// All rights reserved. www.dofactory.com
//
// You are free to use this source code in your
// applications as long as the original copyright
// notice is included.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT
// WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//--------------------------------------------------------

using System;

// "AbstractFactory"
abstract class ContinentFactory {
  // Methods
  abstract public Herbivore CreateHerbivore();
  abstract public Carnivore CreateCarnivore();
}

// "ConcreteFactory1"
class AfricaFactory : ContinentFactory {
  // Methods
  override public Herbivore CreateHerbivore() {
    return new Wildebeest();
  }
  override public Carnivore CreateCarnivore() {
    return new Lion();
  }
}

// "ConcreteFactory2"
class AmericaFactory : ContinentFactory {
  // Methods
  override public Herbivore CreateHerbivore() {
    return new Bison();
  }
  override public Carnivore CreateCarnivore() {
    return new Wolf();
  }
}

// "AbstractProductA"
abstract class Herbivore {
}

// "AbstractProductB"
abstract class Carnivore {
  // Methods
  abstract public void Eat( Herbivore h );
}

// "ProductA1"
class Wildebeest : Herbivore {
}

// "ProductB1"
class Lion : Carnivore {
  // Methods
  override public void Eat( Herbivore h ) {
    // eat wildebeest
    Console.WriteLine( this + " eats " + h );
  }
}

// "ProductA2"
class Bison : Herbivore {
}

// "ProductB2"
class Wolf : Carnivore {
  // Methods
  override public void Eat( Herbivore h ) {
    // Eat bison
    Console.WriteLine( this + " eats " + h );
  }
}

// "Client"
class AnimalWorld {
  // Fields
  private Herbivore herbivore;
  private Carnivore carnivore;

  // Constructors
  public AnimalWorld( ContinentFactory factory ) {
    carnivore = factory.CreateCarnivore();
    herbivore = factory.CreateHerbivore();
  }

  // Methods
  public void RunFoodChain() {
    carnivore.Eat( herbivore );
  }
}

///

/// GameApp test class
///

class GameApp {
  public static void Main( string[] args ) {
    // Create and run the Africa animal world
    ContinentFactory africa = new AfricaFactory();
    AnimalWorld world = new AnimalWorld( africa );
    world.RunFoodChain();

    // Create and run the America animal world
    ContinentFactory america = new AmericaFactory();
    world = new AnimalWorld( america );
    world.RunFoodChain();

    Console.Read();
  }
}

毒菇求Buy 2005-07-06 08:39 发表评论

Software Design Patterns

毒菇求Buy — Tue, 05 Jul 2005 23:59:00 GMT

Design patterns are recurring solutions to software design problems you find again and again in real-world application development. Design patterns are about design and interaction of objects, as well as providing a communication platform concerning elegant, reusable solutions to commonly encountered programming challenges.

The Gang of Four (GOF) patterns are generally considered the foundation for all other patterns. They are categorized in three groups: Creational, Structural, and Behavioral. Here you will find information on these patterns together with downloadable source code in C#.

To give you a head start, the source code is provided in two forms: structural and real-world. Structural code uses type names as defined in the pattern definition and UML diagrams. Real-world code provides real-world programming situations where you may use the patterns. Let us know if you find these useful.

Creational Patterns
Abstract Factory	Creates an instance of several families of classes
Builder	Separates object construction from its representation
Factory Method	Creates an instance of several derived classes/TD>
Prototype	A fully initialized instance to be copied or cloned
Singleton	A class of which only a single instance can exist
Structural Patterns
Adapter	Match interfaces of different classes
Bridge	Separates an object’s interface from its implementation
Composite	A tree structure of simple and composite objects
Decorator	Add responsibilities to objects dynamically
Façade	A single class that represents an entire subsystem
Flyweight	A fine-grained instance used for efficient sharing
Proxy	An object representing another object
Behavioral Patterns
Chain of Resp.	A way of passing a request between a chain of objects
Command	Encapsulate a command request as an object
Interpreter	A way to include language elements in a program
Iterator	Sequentially access the elements of a collection
Mediator	Defines simplified communication between classes
Memento	Capture and restore an object's internal state
Observer	A way of notifying change to a number of classes
State	Alter an object's behavior when its state changes
Strategy	Encapsulates an algorithm inside a cla
Template Method	Defer the exact steps of an algorithm to a subclass
Visitor	Defines a new operation to a class without change

毒菇求Buy 2005-07-06 07:59 发表评论