Design Patterns

Chain of Responsibility Design Pattern

April 9, 2017 by ashish Leave a Comment

Name:Chain of responsibility design pattern

Type:Behavioral Design Pattern

The Chain of responsibility design pattern is a behavioral pattern.It is useful when you want to give more than one handler chance to handle the request.
The request is passed along a chain of handlers until it is handled by one of the handlers in the chain or none of handlers is able to handle the request.The response is then returned to the client.

Another feature of the Chain of responsibility pattern is that the request is decoupled from the handler.

Example of Chain of responsibility design pattern

Following is an example of Chain of responsibility pattern.We are taking example of e-commerce application which has multiple supply agents for different products.User can request different types of items.These items can be supplied by any of the supply chain agents.

As you can observe we are passing the request for item to a chain of different handlers.Handlers here are supply chain agents.If a request for an item is not handled by one handler ,which is supply agent ,then it is passed to the next handler.

Item class represents an item which is sold by the e commerce company.

public class Item
{
public string Type { get; set; }
}

We are defining the abstract class which represents different request handlers as:

abstract class RequestHandler
{
protected RequestHandler successor;

public void SetSuccessor(RequestHandler successor)
{
this.successor = successor;
}

public abstract void HandleRequest(Item mobile);
}

class ElectronicsSupplyAgent : RequestHandler
{
public override void HandleRequest(Item item)
{
if (item.Type=="electronics")
{
Console.WriteLine("requesnt handled by ElectronicsSupplyAgent");

}
else if (successor != null)
{
successor.HandleRequest(item);
}
}

}

We are defining supply chain agents which sell different items as derived classes of Request Handler:

class BooksSupplyAgent : RequestHandler
{
public override void HandleRequest(Item item)
{
if (item.Type == "books")
{
Console.WriteLine("request handled by BooksSupplyAgent");

}
else if (successor != null)
{
successor.HandleRequest(item);
}
}

}

class ClothesSupplyAgent : RequestHandler
{
public override void HandleRequest(Item item)
{
if (item.Type == "books")
{
Console.WriteLine("request handled by BooksSupplyAgent");

}
else if (successor != null)
{
successor.HandleRequest(item);
}
}

}

The above classes define the main components of the Chain of responsibility design pattern.

We call the handlers in our main method as:

RequestHandler electronicsSupplyAgent = new ElectronicsSupplyAgent();
RequestHandler booksSupplyAgent = new BooksSupplyAgent();
ClothesSupplyAgent clothesSupplyAgent = new ClothesSupplyAgent();

List<RequestHandler> handlers = new List<RequestHandler>();

electronicsSupplyAgent.SetSuccessor(booksSupplyAgent);
booksSupplyAgent.SetSuccessor(clothesSupplyAgent);
handlers.Add(electronicsSupplyAgent);
handlers.Add(booksSupplyAgent);
handlers.Add(clothesSupplyAgent);
Item item = new Item { Type = "electronics" };
handlers.ForEach(o => o.HandleRequest(item));

It is a very basic example of Chain of responsibility design pattern.You can create different implementations of this pattern depending upon the scenario.

ashish

Follow on:

Use and Example of Singleton Pattern in C#

October 26, 2015 by ashish Leave a Comment

Name Singleton
Type Creational Pattern

Many times we need to restrict a class to only a single instance.Singleton pattern restricts the clients of the class from creating multiple instances of the class.There is a global access point ,such as a method,which returns the same object every time it is invoked.Singleton pattern is a creational pattern since it specifies how to create an object of a class.Here we will see the use and example of Singleton pattern in C#.

We can represent Singleton pattern with the following diagram

To implement singleton pattern follow the below steps

Declare a private constructor: This ensures that consumers of the class can not create objects of the class.If we allow consumers to create new objects then we will not be able to restrict the class to a single instance.
Declare a static field in the class.
Declare a static method: This will return the static field declared in step 2.This method will create a new instance of the field if its doesn’t already exists.

The purpose of step 3 above is to ensure that there is a single interface for accessing the instance of singleton class.Singleton pattern doesn’t specify whether it should be a method or property.So we can implement this as a method or property.

Example of Singleton Pattern

In the following example we have declared a class Singleton which implements the Singleton pattern.This class defines a private constructor,a static field and a method CreateObject.CreateObject method created a new object of the class if it doesn’t exists.

There is an Id property which uniquely identifies each object.As this class can have only single instance so this property will never be incremented and should be always 1.

public class Singleton
{
private static Singleton _object;
public int Id { get; set; }
private Singleton()
{
Id = Id + 1;
}
public static Singleton CreateObject()
{
if (_object == null)
{
_object = new Singleton();
}

return _object;
}

}

User create new object of the Singleton class by calling the CreateObject() method.We are calling the CreateObject method two times.We assign the references returned by the method calls to two different variables.

When we compare the two object references as:

singletonObject1==singletonObject2

they should be equal.

class Program
{
static void Main(string[] args)
{
//Following is not allowed and will give compilation error
//int id = 1;
//Singleton obj = new Singleton(id);

Singleton singletonObject1 = Singleton.CreateObject();
Console.WriteLine("Object created.Object id is {0}", singletonObject1.Id);

//try to create second object
Singleton singletonObject2 = Singleton.CreateObject();
Console.WriteLine("Object created.Object id is {0}", singletonObject2.Id);

if(singletonObject1==singletonObject2)
{
Console.WriteLine("Can not create second object.Singleton class can have only a single instance");
}
else
{
Console.WriteLine("Successfully created second object");
}
Console.ReadLine();
}
}

As we can see from the output both the object references refers to the same object

We have used static method above to create instance of the singleton class.We could use static property instead of static method in our Singleton class:

public class Singleton
{
private static readonly Singleton _object= new Singleton();
public int Id { get; set; }
private Singleton()
{
Id = Id + 1;
}
 public static Singleton Instance
 {
 get
 {
 return _object;
 }
 }

}

Use of Singleton pattern

Some of the scenarios where Singleton pattern could be useful are:

A common use of Singleton pattern is implementing the logging class.Since logging class needs to be used multiple times in a application hence it is useful to implement it as a singleton.
Often data fetched from a database needs to be cached.This cache class can be implemented as a singleton class since we need to have a single instance of the cached items.
If we have an object that is resource intensive and so expensive to create ,it’s useful to implement it as a singleton.

Problem to avoid when implementing Singleton pattern

A problem can occur when there are singleton class is simultaneously accessed in a multi-threaded environment .In such cases the first call to singleton class creates an object,but it is not visible to the second call.So the second access to singleton class will try to again create an object of the singleton class.

A simple solution to concurrency is using the C# lock statement

lock (_object)
{
if (_object == null)
{
_object = new Singleton();
}
return _object;
}

A common example of Singleton Pattern in C# is implementing logger as a singleton class.Since logging is a cross cutting concern so it can implemented as a singleton class.

When developing a application design patterns should be chosen cautiously after weighing the pros and cons.Singleton design pattern is useful when the primary requirement is to limit the number of instances to a single instance.There could be different ways to implement the same design pattern.In the above example we have implemented singleton pattern in c# using a method but we could have used a property instead.

ashish

Follow on:

Use and example of Proxy Design Pattern

September 15, 2015 by ashish shukla Leave a Comment

Name Proxy
Type Structural Design Pattern
Description An object acts as a placeholder for another object.Client interacts with Proxy(placeholder) rather then actual object.

In the Proxy Design pattern an object called the Proxy is used as a placeholder for another object.The main object provides the actual functionality whereas the proxy object is used just a stand-in object for the real object.Client interacts only with the proxy object instead of the real object.Here we will see the use and example of Proxy Design Pattern.

In Proxy design pattern ,when a request is received by the Proxy object ,it delegates the request to the original object.

Client uses the Proxy object in the similar way it uses the Real object as both implements a common interface.

Use of Proxy Design Pattern

There are many common scenarios in which Proxy pattern is useful:

To simplify use of an object

Perhaps the most common example where Proxy pattern is used is when we create a proxy of a web service.The application uses the Proxy object just as it would use the real object.

Application is not aware that the proxy is calling the web service which can be located anywhere.Web Service could be hosted in a process on the same machine or on a machine in a different country .Client uses the proxy just as it would use a real web service.This is also a example of remote proxy as the proxy object is used to access a remote web service.

In the case of a Remote Proxy different communication mechanisms such as remoting or web services might be used.So instead of exposing these communication details to the client a proxy is used instead.

Protection Proxy

If there is an object which is sensitive then instead of directly exposing the object in our application we can use proxy in our application.So our application is not aware of the existence of the real object and it interacts only with the proxy.The proxy can define the logic to verify the access to the real object.Only if the client is authorized a real object is created.

Virtual Proxy

Here the proxy object is used as a placeholder for an expensive object.Instead of creating the real object when the application is initialized ,a proxy object is created.Proxy object determines when the real object is actually required and only then creates the real object.This reduces the use of the resources ,such as database, until it is actually required.

Implementation of Proxy Design Pattern

We can represent the Proxy Design Pattern with the following UML diagram:

The three main participants in this pattern are:

Proxy Implements the Subject interface.Can be used in place of the RealSubject as both implements the same interface

RealSubject This is the object which provides the actual functionality.It Implements the Subject interface.

Subject Interface which is implemented by both the Proxy and the RealSubject.

Example of Proxy design pattern in C#

We are taking a real scenario of an Organization where each employee has a manager.An employee can have a specific manager.There is some confidential data for every employee which only the assigned manager of the employee should be able to see.

The data here is represented by the IConfidentialInfo interface.This interface defines the operations GetSalary and GetRating which returns the salary and rating of the employee.

Manager of an employee is represented by the Manager class.

Since salary and rating are confidential information of an employee so we are creating a proxy class for Maanger called ManagerProxy.This class contains the logic to verify if the Manger calling the GetSalary and GetRating methods is indeed the designated Manager of an Employee.If any other Manager tries to call these methods we throw UnauthorizedAccessException.

interface IConfidentialInfo
{
decimal GetSalary(int EmployeeId);
int GetRating(int EmployeeId);
}

public class Manager : IConfidentialInfo
{
public int Id { get; set; }
public string Name { get; set; }

public Manager(string name, int id,List<Employee> reportees)
{
Name = name;
Id = id;
Reportees = reportees;
}
private List<Employee> _reportees;
public List<Employee> Reportees
{
get;
set;


}

public decimal GetSalary(int EmployeeId)
{
decimal salary = Reportees.Where(x => x.Id == EmployeeId).Select(x => x.Salary).FirstOrDefault();
return salary;
}

public int GetRating(int EmployeeId)
{
int rating = Reportees.Where(x => x.Id == EmployeeId).Select(x => x.Rating).FirstOrDefault();
return rating;
}
}

public class ManagerProxy : IConfidentialInfo
{
Manager mgr;
public List<Employee> Reportees { get; set; }
public ManagerProxy(string name, int id, List<Employee> reportees)
{
mgr = new Manager(name, id,reportees);
}

public decimal GetSalary(int EmployeeId)
{
Employee emp = mgr.Reportees.Where(x => x.Id == EmployeeId).Select(x => x).FirstOrDefault();
if (emp != null)
{
return emp.Salary;
}
else
{
throw new UnauthorizedAccessException();
}
}

public int GetRating(int EmployeeId)
{
Employee emp = mgr.Reportees.Where(x => x.Id == EmployeeId).Select(x => x).FirstOrDefault();
if (emp != null)
{
return emp.Rating;
}
else
{
throw new UnauthorizedAccessException();
}
}


 public class Employee {
        public string Name { get; set; }
        public int Id { get; set; } 
        public decimal Salary { get; set; }
        public int Rating { get; set; } 
        public Employee(string name, int id, decimal salary, int rating) 
        { 
            Name = name; Id = id; Salary = salary; Rating = rating;
        } 
    }

}

To test the ManagerProxy class we can create instance of the ManagerProxy class and pass different values for employeeIds

static void Main(string[] args)
{

List<Employee> Reportees=new List<Employee>{new Employee("Amit", 1, 10000, 2),
new Employee("Mark", 2, 7000, 1)};
ManagerProxy manager = new ManagerProxy("Marc",32,Reportees);
int employeeId=2;
decimal salary= manager.GetSalary(employeeId);
Console.WriteLine("Salary of Employee with Id {0} is {1}", employeeId, salary);
Console.ReadLine();
}

If we execute the above code we will get the salary of the employee with id 2:

While if we now set the value of employeeId other than 1 or 2 which are valid employee ids for the managers reportees we will get unauthorized exception:

Here we have seen the Use and example of Proxy Design Pattern.We tried to understand when the proxy pattern is useful and how to implement the proxy design pattern in C#.

ashish shukla

Follow on:

Use and Example of Prototype Design Pattern

September 14, 2015 by ashish shukla Leave a Comment

Name Prototype Pattern
Type Creational Pattern

In this design pattern an existing object is copied to a new object.So we get a new object initialized with the state information from an existing object.The new object that is created using the Original object is different from the original object though it contains the same state information.

Since the objects which are created are based on a prototype,which is the original object, so this pattern is called Prototype pattern.

Following are the uses of the Prototype pattern

This pattern is useful if we want to create a copy of an object which is expensive or resource intensive to create.Suppose if we are creating an object which contains data which is fetched from a database through a web service.Now we need to create many more identical objects of this type.In this case it is better if we can reuse the existing object rather than creating new objects multiple times.
We are not required to explicitly set the same properties on a class.Duplication of code is avoided.

Implementation

In the Prototype object define a clone() method.There is an interface called ICloneable which specifies this method.Our prototype can implement this ICloneable interface.

Example of Prototype Pattern

In this example we are taking the example of a School.In a School many students are there and most of the attributes of students are similar.For example students in the same grade will have same subjects.A student has just a few attributes that identifies him.For example student has Name and RollNo which uniquely identifies him.

Since details of Students are fetched from a database so retrieving all the students details from the database could be unnecessary and expensive operation.So we can fetch just the necessary information from the database and use the prototype pattern to create copies of these objects.

We can then fetch the required information for each student such as name and roll number.Since fetching only the required information from the database is less expensive than fetching all the duplicate information so Prototype pattern is a suitable pattern to use here.

 abstract class Student
 {
 public string Name {get;set;}
 public string RollNo { get; set; }
 public string SchoolName { get; set; }
 public string SchoolAddress { get; set; }
 public string SchoolStrength { get; set; }
 public string Principal { get; set; }
 public abstract Student Clone();
 
 }

 
 public class HighSchoolStudent:Student
 {
 //Subjects are unique for High School Students
 public List<Subject> Subjects { get; set; }
 public override Student Clone()
 {
 return this.MemberwiseClone() as Student;
 }
 }

HighSchoolStudent is a type of student who belongs to HighSchool.All HighSchool students share the same subjects.The attributes which makes them unique are the roll number and name.

So we will fetch only a single record for a high school student.Then we fetch only the roll numbers and names of all the students.Finally we clone the single high school student that we fetched and assign the name and roll number to the cloned student.

static void Main(string[] args)
{
StudenService svc=new StudenService();

//GetHighSchoolStudent method will fetch a single record for a high school student
Student student = svc.GetHighSchoolStudent();

//GetNamesandRollNo will fetch the names and roll nos of students in high school
Dictionary<string, string> nameAndRollNos = svc.GetNamesandRollNo();
foreach(var stud in nameAndRollNos)
{
Student highSchoolstudent = student.Clone();
highSchoolstudent.RollNo = stud.Key;
highSchoolstudent.Name = stud.Value;
}
}

So this pattern is useful when we want to create many new objects based on some blueprint.This blueprint is specified by the prototype object.

ashish shukla

Follow on:

Use and Example of Observer Design Pattern

September 12, 2015 by ashish shukla Leave a Comment

Observer design pattern is a behavioral pattern.In this pattern the particiapnts are the Subject and number of Observer objects.Observer object are interested in being notified of the state changes in the Subject.When the state of the Subject changes ,observers are notified of the state changes.There is one to many relationship between the Subject and the observers as one subject maintains a list of observer objects.

To receive updates about the state change of the Subject observer objects needs to register themselves with the subject.When the state of the Subject changes all the registered observer objects are notified of the state change.To stop getting notified of the state changes Subject provides the UnSubscribe method which the observers uses to stop getting notified of the state changes.

Example of Observer Pattern

In the following example we have two entities Library and the Readers.Library represents a library of books from where Readers can borrow and read books.From time to time new books are added to the collection of books in the Library.Reader can know which new book is added to the library.To get the information about the new book Reader needs to subscribe to the library.

When the new book is added all the subscribed readers are informed about the addition of the book.

Library class implements the interface ILibrary which provides methods to Subscribe and Unsubscribe readers.It also maintains a collection of books.

interface ILibrary
{
void Subscribe(Reader observer);
void Unsubscribe(Reader observer);
void Notify(Book book);
}

public class Library : ILibrary
{
private List<Reader> observers = new List<Reader>();
public List<Book> books;

public Library()
{
books = new List<Book>();
}

public void AddBook(Book book)
{
books.Add(book);
Notify(book);
}
public void Subscribe(Reader observer)
{
observers.Add(observer);
}

public void Unsubscribe(Reader observer)
{
observers.Remove(observer);
}

public void Notify(Book book)
{
observers.ForEach(x => x.Update(book));
}
}


public class Book
 {
 public string Name{get;set;}
 }

Readers are represented by the Reader class.The update method of the Reader class is called whenever a new Book is added to the collection of books in the Library.

public class Reader:IReader
{
public string Name { get; set; }
public Reader(string name)
{
this.Name = name;
}
public void Update(Book book)
{
Console.WriteLine("Added a new book titled {0}",book.Name);
}
}

interface IReader
{
void Update(Book book);
}

Now whenever we add a new book in the library ,subscribed readers are notified of the addition of the book

static void Main(string[] args)
{
Library library = new Library();
//Subscribe a new reader
library.Subscribe(new Reader("Reader1" ));
//Add a new book in the library
library.AddBook(new Book { Name = "C# Book" });
}

User is notified of the addition of the book:

This example of the Observer pattern can be represented with the following UML diagram

ashish shukla

Follow on: