1.Topics‎ > ‎Architecture‎ > ‎Patterns‎ > ‎a.Design Patterns‎ > ‎

A.Design Pattern Summary

 Creational Patterns

Example Uses

  Singleton

§  A class of which only a single instance can exist

§ Default constructor is marked as private. A special function “GetInstance” in implanted to get object reference.

§ Initialization can be done either as early (Thread Safe) or Lazy  way

§ Double checked locking is used for ensuring thread safety during instance access and creation.

§ Best way to create singleton is to use Type Constructor with Lazy loading

§ If multiple Class Loaders are involved then use Kernel level synchronization object to achieve singleton effect.

§ Never lock entire singleton object (Lock this) this could lead to deadlock, instead use a dedicated sync object

§ Singleton have several side effect and use only if state are need to be maintained or else need to be passed as parameters.

§ Singleton restrict scalability, for example today we just need one connection manager but in future we may need multiple for load balancing purpose so design need to be chosen carefully

Connection Manager,

Abstract factory

Factory

Pattern

Simple Factory

§ Hides instantiation details from client.

§ Client uses concrete factory to get an instance of product (object) and factory return product as abstract instance.

 

 Factory Method

§ Purpose is same as simple factory but it uses Inheritance

§ An standard factory interface is defined and (sub classed) Concentrate Factory Implement it.

§ Client request to concrete factory for object and factory newly created object through a common (product)interface

 

 Abstract Factory

§ Purpose is same as factory method pattern this factory is used for creating family of related object such as pizza ingredients

§ Client hold an reference of abstract factory that is implemented by more a concrete factory

§ Concrete factory is   capable of creating multiple objects (products)

§ Concrete factory creates several related product and return on common interface (Abstraction)

§ Each product family has its own abstraction root and there is no common interface in between product families.

 

  Builder

§  Separates object construction from its representation

§ Client has director a object that holds and a reference of builder interface

§ Builder interface implement by a concrete builder.  Director request concrete builder (through interface) to compose final product and supply necessary instruction for building final product.

§ Builder return final product through a common product interface.

§ Client can itself work as director.

Product assembly, Menu Building.

  Prototype

§  A fully initialized instance to be copied or cloned

§ Client instantiates first instance of class (called prototype)

§ Then it clone it (via object.clone interface memebr) and modified to create a final concrete product

§ Best suited when large number of object need to share some common basing information such as schema, best example is XML document elements.

XmlDocument, UI Elements

Object Pool

§ Purpose if to reuse and share objects that are expensive to create

§ When a client asks for a Reusable object.

§ Search for an available Reusable object and if it was found it will be returned to the client.

§ If no Reusable object was found then it tries to create a new one.

§ If this actions succeeds the new Reusable object will be returned to the client.

§ If the pool was unable to create a new Reusable, the pool will wait until a reusable object will be released and then will returned to client

§ The Client is responsible to request the Reusable object as well to release it to the pool.

§ The clients are not aware that they are sharing the Reusable object.

§ This design pattern also present the challenges  of Thread Safety, Resource leak (From Pool) infinite client waiting and Synchronization issues  that must be taken care during implementation.

Thread Pool



  Structural Patterns

Example Uses

  Adapter

§ Match interfaces of different classes without code changing of participating classes.   

§ Convert the interface of a class into another interface clients expect.

§ Adapter lets classes work together, that could not otherwise because of incompatible interfaces.

 

  Bridge

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

§ It is usually used when command pattern is in place 

§ Client has a reference of concrete class that implement and abstraction (such as Remote Control)

§ Abstract “Remote Control” holds an instance of another specialized abstraction (such as TV Remote Control) that will do the same function but for different audience.

§ Specialized abstraction is realized by concrete classes (such as  Sony TV Remote)

§ In this case same remote can used for any derived class at run time because client interface is talking only to implementation (Generic TV Remote) and client can change the implementation at both end of aggregation at run time.

Extension of command pattern,

TV Remote,

Alternative to Adapter if code change is allowed.

  Composite

§ Implements tree structure (whole Part  relationship)

§ Client has a reference to component interface that is realized by either leaf or composite (Node) implementation.

§ Each node (Composite) can have one or more references of component interface that will further hold the references of either leaf or node object

§ Technically it is three data structure and in most of the implementation node and leaf share same class schema and differ only in terms of sibling references that is null in case of leaf object.

File System Object , Xml Document

  Decorator

§  Add responsibilities to objects dynamically

§ Client holds an instance of abstract component (Interface) such as ICoffee

§ Abstraction (ICofee) is realized by Concrete Cofee(Such as Dark Coffee)   and toppings such as (Cream, milk and sugar)

§ Each toppings holds a reference of Component (ICoffee) that in turn can either holds Concrete Component such as (Dark Coffee ) or toppings (Decorator Milk etc), but client is still holding just one reference of base abstraction.

§ This pattern actually implement a link list of object that talk in a cyclic manner in a predefined order and client just know one reference first object that may be concrete object or decorated object (List Head).

Coffee machine Simulator,

  Facade

§  A single class that represents an entire subsystem

§  It usually created by aggregation of all the component of a large system for example Music Theater Controller.

§ In this pattern client just talk to top level object (facade)and rest of the complexity  is handled by  facade

§ For improving facade performance is lazy init (initialization on demand) and object recycling if required.

 

 

  Flyweight

§ A fine-grained instance used for efficient sharing of object.

§ Applicable when a large number of object shares significant about of state information (called intrinsic or shared) with minimum extrinsic (unshared) state information.

§ Client holds a “Flyweight Factory” and request of object to “Flyweight Factory”

§ “Flyweight Factory” holds a reference of Flyweight interface that in turn holds Flyweight object created by “Flyweight Factory”.

§ Flyweight Interface is implemented by Concrete flyweight such as Tree.

§ “Flyweight Factory” maintains extrinsic state data and provide to client when ever required and client is responsible for passing “extrinsic state data” to shared object (Flyweight).

War game simulator that need large number of solder object.

  Proxy

§ An object representing another object

§ Mostly used for Remote method Invocation or Controlling object access to protected resource as well as logging

§ Client holds a reference of IProxy interface that actually holds Proxy Object.

§ Both Proxy and Target Object implement same IProxy

§ Client invokes IProxy members that in turns invoke Target Object members hiding any additional complexity    

 



  Behavioral Patterns

Example Uses

Chain of Resp.

§ A way of passing a request between a chain of handlers

§ It decouples request sender handles (receiver).

§ Handlers are usually linked list and request object become parts of a chain and the request is sent from one object to another object across the chain until one of the objects will handle it.

 

  Command     

§ Encapsulate a request in an object and allows the parameterization of clients with different requests optionally saves the requests in a queue.

§ Client creates a concrete command and pushes it to invoker.

§ Invoker call execute function of command that activate Receiver (Target Object on which command need to work on)

§ Once done command return a final outcome to client via invoker.

§ The main advantage of the command design pattern is that it decouples the object that invokes the operation from the one that know how to perform it.

§ The invoker should be aware only about the abstract command class.

§ Client can also work as invoker in simple scenario.

 

  Interpreter

§ A way to include language elements in a program

§ The implementation of the Interpreter pattern is just the use of the composite pattern applied to represent a grammar.

§ The Interpreter defines the behavior while the composite defines only the structure.

Note This pattern is not frequently used.

 

  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 class

 

 Template Method

  Defer the exact steps of an algorithm to a subclass

 

  Visitor

  Defines a new operation to a class without change