Prototype Design Pattern - C#

Prototype pattern falls under Creational Pattern of Gang of Four (GOF) Design Patterns in .Net. It is used to used to create a duplicate object or clone of the current object. It provides an interface for creating parts of a product. In this article, I would like share what is Prototype pattern and how is it work?

What is Prototype Pattern?

Prototype pattern is used to create a duplicate object or clone of the current object to enhance performance. This pattern is used when creation of object is costly or complex.

For Example: An object is to be created after a costly database operation. We can cache the object, returns its clone on next request and update the database as and when needed thus reducing database calls.

Prototype Pattern - UML Diagram & Implementation

The UML class diagram for the implementation of the Prototype design pattern is given below:

The classes, interfaces and objects in the above UML class diagram are as follows:

1. Prototype

   This is an interface which is used for the types of object that can be cloned itself.

2. ConcretePrototype

   This is a class which implements the Prototype interface for cloning itself.

C# - Implementation Code

public interface Prototype
{
 Prototype Clone();
}
public class ConcretePrototypeA : Prototype
{
 public Prototype Clone()
 {
 // Shallow Copy: only top-level objects are duplicated
 return (Prototype)MemberwiseClone();
 // Deep Copy: all objects are duplicated
 //return (Prototype)this.Clone();
 }
}
public class ConcretePrototypeB : Prototype
{
 public Prototype Clone()
 {
 // Shallow Copy: only top-level objects are duplicated
 return (Prototype)MemberwiseClone();
 // Deep Copy: all objects are duplicated
 //return (Prototype)this.Clone();
 }
}

Prototype Pattern - Example

Who is what?

The classes, interfaces and objects in the above class diagram can be identified as follows:

1. IEmployee - Prototype interface

2. Developer & Typist- Concrete Prototype

C# - Sample Code

/// <summary>
/// The 'Prototype' interface
/// </summary>
public interface IEmployee
{
 IEmployee Clone();
 string GetDetails();
}
/// <summary>
/// A 'ConcretePrototype' class
/// </summary>
public class Developer : IEmployee
{
 public int WordsPerMinute { get; set; }
 public string Name { get; set; }
 public string Role { get; set; }
 public string PreferredLanguage { get; set; }
 public IEmployee Clone()
 {
 // Shallow Copy: only top-level objects are duplicated
 return (IEmployee)MemberwiseClone();
 // Deep Copy: all objects are duplicated
 //return (IEmployee)this.Clone();
 }
 public string GetDetails()
 {
 return string.Format("{0} - {1} - {2}", Name, Role, PreferredLanguage);
 }
}
/// <summary>
/// A 'ConcretePrototype' class
/// </summary>
public class Typist : IEmployee
{
 public int WordsPerMinute { get; set; }
 public string Name { get; set; }
 public string Role { get; set; }
 public IEmployee Clone()
 {
 // Shallow Copy: only top-level objects are duplicated
 return (IEmployee)MemberwiseClone();
 // Deep Copy: all objects are duplicated
 //return (IEmployee)this.Clone();
 }
 public string GetDetails()
 {
 return string.Format("{0} - {1} - {2}wpm", Name, Role, WordsPerMinute);
 }
}
/// <summary>
/// Prototype Pattern Demo
/// </summary>
class Program
{
 static void Main(string[] args)
 {
 Developer dev = new Developer();
 dev.Name = "Rahul";
 dev.Role = "Team Leader";
 dev.PreferredLanguage = "C#";
 Developer devCopy = (Developer)dev.Clone();
 devCopy.Name = "Arif"; //Not mention Role and PreferredLanguage, it will copy above
 Console.WriteLine(dev.GetDetails());
 Console.WriteLine(devCopy.GetDetails());
 Typist typist = new Typist();
 typist.Name = "Monu";
 typist.Role = "Typist";
 typist.WordsPerMinute = 120;
 Typist typistCopy = (Typist)typist.Clone();
 typistCopy.Name = "Sahil";
 typistCopy.WordsPerMinute = 115;//Not mention Role, it will copy above
 Console.WriteLine(typist.GetDetails());
 Console.WriteLine(typistCopy.GetDetails());
 Console.ReadKey();
 }
}

Prototype Pattern Demo - Output

When to use it?

1. The creation of each object is costly or complex.

2. A limited number of state combinations exist in an object.

What do you think?

I hope you will enjoy the Prototype Pattern while designing your software. I would like to have feedback from my blog readers. Your valuable feedback, question, or comments about this article are always welcome.

Further Reading