Konsep dasar Design Pattern, Design Framework dan arsitektur software

• Erich Gamma
  
• Richard Helm
  
• John Vlissides
  
• Ralph Johnson
  
• 
  

using System;



namespace DoFactory.GangOfFour.Singleton.Structural

{



  /// <summary>

  /// MainApp startup class for Structural

  /// Singleton Design Pattern.

  /// </summary>

  class MainApp

  {



    /// <summary>

    /// Entry point into console application.

    /// </summary>

    static void Main()

    {



      // Constructor is protected -- cannot use new

      Singleton s1 = Singleton.Instance();

      Singleton s2 = Singleton.Instance();



      // Test for same instance

      if (s1 == s2)

      {

        Console.WriteLine("Objects are the same instance");

      }



      // Wait for user

      Console.ReadKey();

    }

  }





  /// <summary>

  /// The 'Singleton' class

  /// </summary>

  class Singleton

  {

    private static Singleton _instance;



    // Constructor is 'protected'

    protected Singleton()

    {

    }



    public static Singleton Instance()

    {

      // Uses lazy initialization.

      // Note: this is not thread safe.

      if (_instance == null)

      {

        _instance = new Singleton();

      }



      return _instance;

    }

  }

}

//Abstract Builder

class abstract class TextConverter{

 abstract void convertCharacter(char c);

 abstract void convertParagraph();

}



// Product

class ASCIIText{

 public void append(char c){ //Implement the code here }

}



//Concrete Builder

class ASCIIConverter extends TextConverter{

 ASCIIText asciiTextObj;//resulting product



 /*converts a character to target representation and appends to the resulting*/

 object void convertCharacter(char c){

  char asciiChar = new Character(c).charValue();

   //gets the ascii character

  asciiTextObj.append(asciiChar);

 }

 void convertParagraph(){}

 ASCIIText getResult(){

  return asciiTextObj;

 }

}



//This class abstracts the document object

class Document{

 static int value;

 char token;

 public char getNextToken(){

  //Get the next token

  return token;

 }

}



//Director

class RTFReader{

 private static final char EOF='0'; //Delimitor for End of File

 final char CHAR='c';

 final char PARA='p';

 char t;

 TextConverter builder;

 RTFReader(TextConverter obj){

  builder=obj;

 }

 void parseRTF(Document doc){

  while ((t=doc.getNextToken())!= EOF){

   switch (t){

    case CHAR: builder.convertCharacter(t);

    case PARA: builder.convertParagraph();

   }

  }

 }

}



//Client

public class Client{

 void createASCIIText(Document doc){

  ASCIIConverter asciiBuilder = new ASCIIConverter();

  RTFReader rtfReader = new RTFReader(asciiBuilder);

  rtfReader.parseRTF(doc);

  ASCIIText asciiText = asciiBuilder.getResult();

 }

 public static void main(String args[]){

  Client client=new Client();

  Document doc=new Document();

  client.createASCIIText(doc);

  system.out.println("This is an example of Builder Pattern");

 }

}

public interface Order {

    public abstract void execute ( );

}



// Receiver class.

class StockTrade {

    public void buy() {

        System.out.println("You want to buy stocks");

    }

    public void sell() {

        System.out.println("You want to sell stocks ");

    }

}



// Invoker.

class Agent {

    private m_ordersQueue = new ArrayList();

    public Agent() {

    }

    

    void placeOrder(Order order) {

        ordersQueue.addLast(order);

        order.execute(ordersQueue.getFirstAndRemove());

    }    

}



//ConcreteCommand Class.

class BuyStockOrder implements Order {

    private StockTrade stock;

    public BuyStockOrder ( StockTrade st) {

        stock = st;

    }

    public void execute( ) {

        stock . buy( );

    }

}



//ConcreteCommand Class.

class SellStockOrder implements Order {

    private StockTrade stock;

    public SellStockOrder ( StockTrade st) {

        stock = st;

    }

    public void execute( ) {

        stock . sell( );

    }

}



// Client

public class Client {

    public static void main(String[] args) {

        StockTrade stock = new StockTrade();

        BuyStockOrder bsc = new BuyStockOrder (stock);

        SellStockOrder ssc = new SellStockOrder (stock);

        Agent agent = new Agent();



        agent.placeOrder(bsc); // Buy Shares

        agent.placeOrder(ssc); // Sell Shares

    }

}

namespace DoFactory.GangOfFour.Adapter.RealWorld

{



  /// <summary>MainApp startup class for Real-World Adapter Design Pattern.</summary>

  class MainApp

  {



    /// <summary>

    /// Entry point into console application.

    /// </summary>

    static void Main()

    {

      // Non-adapted chemical compound

      Compound unknown = new Compound("Unknown");

      unknown.Display();



      // Adapted chemical compounds

      Compound water = new RichCompound("Water");

      water.Display();

 

      Compound benzene = new RichCompound("Benzene");

      benzene.Display();



      Compound ethanol = new RichCompound("Ethanol");

      ethanol.Display();

 

      // Wait for user

      Console.ReadKey();



    }

  }



  /// <summary>

  /// The 'Target' class.</summary>

  class Compound

  {



    protected string _chemical;

    protected float _boilingPoint;

    protected float _meltingPoint;

    protected double _molecularWeight;

    protected string _molecularFormula;



    // Constructor

    public Compound(string chemical)

    {

      this._chemical = chemical;

    }



    public virtual void Display()

    {

      Console.WriteLine("\nCompound: {0} ------ ", _chemical);

    }

  }





  /// <summary>The 'Adapter' class</summary>

  class RichCompound : Compound

  {



    private ChemicalDatabank _bank;



    // Constructor

    public RichCompound(string name)

      : base(name)

    {



    }



    public override void Display()

    {



      // The Adaptee

      _bank = new ChemicalDatabank();

      _boilingPoint = _bank.GetCriticalPoint(_chemical, "B");

      _meltingPoint = _bank.GetCriticalPoint(_chemical, "M");

      _molecularWeight = _bank.GetMolecularWeight(_chemical);

      _molecularFormula = _bank.GetMolecularStructure(_chemical);



      base.Display();

      Console.WriteLine(" Formula: {0}", _molecularFormula);

      Console.WriteLine(" Weight : {0}", _molecularWeight);

      Console.WriteLine(" Melting Pt: {0}", _meltingPoint);

      Console.WriteLine(" Boiling Pt: {0}", _boilingPoint);

    }



  }



  /// <summary>The 'Adaptee' class.</summary>

  class ChemicalDatabank

  {



    // The databank 'legacy API'

    public float GetCriticalPoint(string compound, string point)

    {



      // Melting Point

      if (point == "M")

      {



        switch (compound.ToLower())

        {



          case "water": return 0.0f;

          case "benzene": return 5.5f;

          case "ethanol": return -114.1f;

          default: return 0f;

        }

      }



      // Boiling Point



      else

      {



        switch (compound.ToLower())

        {



          case "water": return 100.0f;

          case "benzene": return 80.1f;

          case "ethanol": return 78.3f;

          default: return 0f;

        }

      }

    }



    public string GetMolecularStructure(string compound)

    {

      switch (compound.ToLower())

      {

        case "water": return "H20";

        case "benzene": return "C6H6";

        case "ethanol": return "C2H5OH";

        default: return "";

      }

    }

 

    public double GetMolecularWeight(string compound)

    {

      switch (compound.ToLower())

      {

        case "water": return 18.015;

        case "benzene": return 78.1134;

        case "ethanol": return 46.0688;

        default: return 0d;

      }

    }

  }

}

namespace DoFactory.GangOfFour.Facade.Structural

{



  /// <summary>

  /// MainApp startup class for Structural

  /// Facade Design Pattern.

  /// </summary>

  class MainApp

  {



    /// <summary>

    /// Entry point into console application.

    /// </summary>

    public static void Main()

    {



      Facade facade = new Facade();



      facade.MethodA();



      facade.MethodB();



      // Wait for user

      Console.ReadKey();

    }

  }



  /// <summary>

  /// The 'Subsystem ClassA' class

  /// </summary>

  class SubSystemOne

  {



    public void MethodOne()

    {

      Console.WriteLine(" SubSystemOne Method");

    }

  }



  /// <summary>

  /// The 'Subsystem ClassB' class

  /// </summary>

  class SubSystemTwo

  {



    public void MethodTwo()

    {

      Console.WriteLine(" SubSystemTwo Method");

    }

  }



  /// <summary>

  /// The 'Subsystem ClassC' class

  /// </summary>

  class SubSystemThree

  {



    public void MethodThree()

    {

      Console.WriteLine(" SubSystemThree Method");

    }

  }



  /// <summary>

  /// The 'Subsystem ClassD' class

  /// </summary>

  class SubSystemFour

  {

    public void MethodFour()

    {

      Console.WriteLine(" SubSystemFour Method");

    }

  }



  /// <summary>

  /// The 'Facade' class

  /// </summary>

  class Facade

  {



    private SubSystemOne _one;

    private SubSystemTwo _two;

    private SubSystemThree _three;

    private SubSystemFour _four;



    public Facade()

    {

      _one = new SubSystemOne();

      _two = new SubSystemTwo();

      _three = new SubSystemThree();

      _four = new SubSystemFour();

    }

 

    public void MethodA()

    {

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

      _one.MethodOne();

      _two.MethodTwo();

      _four.MethodFour();

    }



    public void MethodB()

    {

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

      _two.MethodTwo();

      _three.MethodThree();



    }

  }

}