ashish shukla

• 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

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

Adapter Design Pattern

Adapter design pattern is a structural pattern.Adapter pattern lets two components work together which have incompatible interfaces.It is useful if we need to implement some functionality in our application and a class already exists which provides the required functionality.But The existing class providing the required functionality has a different interface than the one expected by the client.Here we will understand use and example of Adapter Design Pattern in C#.

In this case modifying the source code of either the client or the class providing the desired functionality is not a good option.So we can create and use an adapter which will serve as an interface between the client class and the service class.

We can describe the Adapter Pattern with the following UML diagram

The 4 main components in this pattern are

• Client   Class which consumes the functionality defined by the Adaptee
• ITarget  Interface which the client uses
• Adapter  Class which converts or Adapts the ITarget interface to the Adaptee
• Adaptee  Class which provides the functionality required by the client.

Adapter is an adapter that converts an existing interface into one required by the client.Adapter contains a reference to the Adaptee.When client calls the Operation() method defined by the adapter,Adapter calls the OriginalOperation() which is defined by the Adaptee.

Like a real world adapter it allows different components to work together.A common example is usb cable.We can not directly plugin the usb cable into the power socket.But using an adapter we can plugin the usb cable into the power socket.

By using the adapter client is able to use the existing functionality provided by the Adaptee class.

Example of Adapter pattern

Our application defines a Student class:

class Student:ILogger
        {
            public string Name { get; set; }
            public string LogPath
            {
                get
                {
                    return ConfigurationManager.AppSettings["loggingPath"];
                }
            }

            private Logger _logger;

            public Logger Logger
            {
                get
                {
                    if(_logger==null)
                    {
                        _logger = new Logger();
                    }
                    return _logger;
                }
            }

            public Student(string name)
            {
                Name = name;
                LoggingInfo(String.Format("Creating student with name {0}", name), LogPath);
            }
       
            public void LoggingInfo(string message, string filePath)
            {
 	            Logger.Log(message,filePath);
            }
}
interface ILogger
        {
            void LoggingInfo(string message,string filePath);
        }

For the logging functionality there is an existing class Logger.The Logger class is defined in an external assembly

public class Logger
{
public void Log(string filePath,string message)
{
using (StreamWriter file =new StreamWriter(filePath, true))
{
file.WriteLine(message);
}
}
}

Now in some client application there is a problem in finding logged details as thousands of messages are being logged everyday.
Because of this the interface of this class changes and instead of just passing the message to log it also requires the date and time details as well.But our application is already calling the Log method in lots of places.
We do not have access to the source code of the Logger class as it is defined in an external assembly.So this will require changes at many places in the application.Also application will need to be thoroughly tested after these changes.

To prevent this problem we can call the log method of the logger class through an adapter rather than directly calling the LoggingInfo() method.

So we define the adapter class as:

public class LoggerAdapter:ILogger
{
const string LogPath=ConfigurationManager.AppSettings["MessageLoggingPath"];

private Logger _logger;

public Logger Logger
{
get
{
if (_logger == null)
{
_logger = new Logger();
}
return _logger;
}
}
public void LoggingInfo(string message)
{
LoggingInfo(message, LogPath);
}

public void LoggingInfo(string message, string filePath)
{
Logger.Log(message, filePath);
}
}

This LoggerAdapter class implements the functionality to log information using the Logger class.This decouples other classes from the Logger class.So changes in the Logger class does not impact all the classes in our application.It is only the adapter class that is impacted by the changes in the Logger class.

So our Student class simplifies to

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

private LoggerAdapter _logger;
public LoggerAdapter Logger
{
get
{
if (_logger == null)
_logger = new LoggerAdapter();

return _logger;
}

}

public Student(string name)
{
Name = name;
Logger.LoggingInfo(String.Format("Creating student with name {0}", name));
}

}

With the new requirement to add the date time details to the logged information ILogger is modified to pass the datetime parameter in the LoggingInfo() method.

interface ILogger
{
void LoggingInfo(string message,string filePath,DateTime current);
}

So to pass the date information to the LoggingInfo() method we only need to modify the method in the adapter class:

 public void LoggingInfo(string message)
 {
 LoggingInfo(message, LogPath,DateTime.Now);
 }

 public void LoggingInfo(string message, string filePath,DateTime currentDateTime)
 {
 Logger.Log(message, filePath,currentDateTime);
 }

ashish shukla