#design patterns- structural patterns

[hsiddu]

Differences between Abstract Factory Pattern and Factory Method

Factory Method is used to create one product only but Abstract Factory is about creating families of related or dependent products.

Factory Method pattern exposes a method to the client for creating the object whereas in case ofAbstract Factory they expose a family of related objects which may consist of these Factory methods.

Factory Method pattern hides the construction of single object where as Abstract factory method hides the construction of a family of related objects. Abstract factories are usually implemented using (a set of) factory methods.

AbstractFactory pattern uses composition to delegate responsibility of creating object to another class while Factory design pattern uses inheritance and relies on derived class or sub class to create object.

The idea behind the Factory Method pattern is that it allows for the case where a client doesn't know what concrete classes it will be required to create at runtime, but just wants to get a class that will do the job while AbstractFactory pattern is best utilised when your system has to create multiple families of products or you want to provide a library of products without exposing the implementation details.!

Factory Pattern Implementation: 

AbstractFactory Pattern Implementation:

[hsiddu]

Bridge

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

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

using System;

namespace DoFactory.GangOfFour.Bridge.Structural

{

  /// 

  /// MainApp startup class for Structural

  /// Bridge Design Pattern.

  /// 

  class MainApp

  {

    /// 

    /// Entry point into console application.

    /// 

    static void Main()

    {

      Abstraction ab = new RefinedAbstraction();

      // Set implementation and call

      ab.Implementor = new ConcreteImplementorA();

      ab.Operation();

      // Change implemention and call

      ab.Implementor = new ConcreteImplementorB();

      ab.Operation();

      // Wait for user

      Console.ReadKey();

    }

  }

  /// 

  /// The 'Abstraction' class

  /// 

  class Abstraction

  {

    protected Implementor implementor;

    // Property

    public Implementor Implementor

    {

      set { implementor = value; }

    }

    public virtual void Operation()

    {

      implementor.Operation();

    }

  }

  /// 

  /// The 'Implementor' abstract class

  /// 

  abstract class Implementor

  {

    public abstract void Operation();

  }

  /// 

  /// The 'RefinedAbstraction' class

  /// 

  class RefinedAbstraction : Abstraction

  {

    public override void Operation()

    {

      implementor.Operation();

    }

  }

  /// 

  /// The 'ConcreteImplementorA' class

  /// 

  class ConcreteImplementorA : Implementor

  {

    public override void Operation()

    {

      Console.WriteLine("ConcreteImplementorA Operation");

    }

  }

  /// 

  /// The 'ConcreteImplementorB' class

  /// 

  class ConcreteImplementorB : Implementor

  {

    public override void Operation()

    {

      Console.WriteLine("ConcreteImplementorB Operation");

    }

  }

}

// Bridge pattern -- Real World example

using System;

using System.Collections.Generic;

namespace DoFactory.GangOfFour.Bridge.RealWorld

{

  /// 

  /// MainApp startup class for Real-World

  /// Bridge Design Pattern.

  /// 

  class MainApp

  {

    /// 

    /// Entry point into console application.

    /// 

    static void Main()

    {

      // Create RefinedAbstraction

      Customers customers = new Customers("Chicago");

      // Set ConcreteImplementor

      customers.Data = new CustomersData();

      // Exercise the bridge

      customers.Show();

      customers.Next();

      customers.Show();

      customers.Next();

      customers.Show();

      customers.Add("Henry Velasquez");

      customers.ShowAll();

      // Wait for user

      Console.ReadKey();

    }

  }

  /// 

  /// The 'Abstraction' class

  /// 

  class CustomersBase

  {

    private DataObject _dataObject;

    protected string group;

    public CustomersBase(string group)

    {

      this.group = group;

    }

    // Property

    public DataObject Data

    {

      set { _dataObject = value; }

      get { return _dataObject; }

    }

    public virtual void Next()

    {

      _dataObject.NextRecord();

    }

    public virtual void Prior()

    {

      _dataObject.PriorRecord();

    }

    public virtual void Add(string customer)

    {

      _dataObject.AddRecord(customer);

    }

    public virtual void Delete(string customer)

    {

      _dataObject.DeleteRecord(customer);

    }

    public virtual void Show()

    {

      _dataObject.ShowRecord();

    }

    public virtual void ShowAll()

    {

      Console.WriteLine("Customer Group: " + group);

      _dataObject.ShowAllRecords();

    }

  }

  /// 

  /// The 'RefinedAbstraction' class

  /// 

  class Customers : CustomersBase

  {

    // Constructor

    public Customers(string group)

      : base(group)

    {

    }

    public override void ShowAll()

    {

      // Add separator lines

      Console.WriteLine();

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

      base.ShowAll();

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

    }

  }

  /// 

  /// The 'Implementor' abstract class

  /// 

  abstract class DataObject

  {

    public abstract void NextRecord();

    public abstract void PriorRecord();

    public abstract void AddRecord(string name);

    public abstract void DeleteRecord(string name);

    public abstract void ShowRecord();

    public abstract void ShowAllRecords();

  }

  /// 

  /// The 'ConcreteImplementor' class

  /// 

  class CustomersData : DataObject

  {

    private List<string> _customers = new List<string>();

    private int _current = 0;

    public CustomersData()

    {

      // Loaded from a database

      _customers.Add("Jim Jones");

      _customers.Add("Samual Jackson");

      _customers.Add("Allen Good");

      _customers.Add("Ann Stills");

      _customers.Add("Lisa Giolani");

    }

    public override void NextRecord()

    {

      if (_current <= _customers.Count - 1)

      {

        _current++;

      }

    }

    public override void PriorRecord()

    {

      if (_current > 0)

      {

        _current--;

      }

    }

    public override void AddRecord(string customer)

    {

      _customers.Add(customer);

    }

    public override void DeleteRecord(string customer)

    {

      _customers.Remove(customer);

    }

    public override void ShowRecord()

    {

      Console.WriteLine(_customers[_current]);

    }

    public override void ShowAllRecords()

    {

      foreach (string customer in _customers)

      {

        Console.WriteLine(" " + customer);

      }

    }

  }

}