Jean Paul's Blog

There are 2 types of People in the World, One who Likes SharePoint and..

  • Microsoft MVP

  • MindCracker MVP

  • CodeProject MVP

  • eBook on SharePoint 2010

  • eBook on Design Patterns

  • eBook on Windows Azure

  • NLayers Framework @ CodePlex

  • MSDN Forums

  • .Net vs. Java

    Due to Public Demand
  • Advertisements

Prototype Pattern

Posted by Paul on January 13, 2012

In this article I would like to explain the Prototype Pattern and C# support for it. The prototype pattern provides an alternative to instantiating new objects by copying the prototype of an existing one.


You are working on an application having setting stored in class Settings. The properties of the class are assignedinside the constructor. It involves calling the configuration file, security database, user profile database etc.

You need to pass the above instance to a component inside a library. The component could play around with the properties so we need to send only another instance of Settings. As the instance creation is expensive we need to create a copy of the above instance.

What would be the best approach?


“Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype”


We can use the Prototype pattern to address this scenario. This pattern allows us to create a new instance by prototyping an existing instance with required properties.


The System.object class includes new method named MemberwiseClone() which provides a shallow copy of the current object. Shallow copy involves copying only the value types. Coupled with ICloneable interface we can provide a Clone() method that invokes MemberwiseClone() for the Settings class.

publicclassSettings : ICloneable


public Settings()


// Load ApplicationSettings from Configuration

// Load ThemeSettings from Database

// Load UserSettings from Database

Thread.Sleep(3000); // Simulate a delay for the above operations

ApplicationSettings = “ApplicationSettings1”;

ThemeSettings = “ThemeSettings1”;

UserSettings = “UserSettings1”;

















publicobject Clone()






returnthis.ApplicationSettings + ” ” +

this.ThemeSettings + ” ” +




Executing the Application

Now we can try playing with the class instances. First we create an instance of Settings (which is a 3 second delay process). Later we take a clone of the Settings instance and modify the properties. We can see that the new instance was created using Clone() method.

staticvoid Main(string[] args)


Settingssettings = newSettings();

SettingssettingsClone = (Settings)settings.Clone();

settingsClone.ApplicationSettings = “NewSettings”; // Change property

Console.WriteLine(“INSTANCE 1: ” + settings.ToString());

Console.WriteLine(“INSTANCE 2: ” + settingsClone.ToString());



On executing the application we can see the following results.


We can see from the above code that:

1. Instance 1 was created using new keyword

2. Instance 2 was created using Clone() method

3. Changing of Instance 2 does not affect Instance 1

So this concludes our experiment with the Prototype pattern.



In this article we have explored the Prototype pattern. The usage of Prototype pattern can be summarized as:

· Faster instance creation with required properties

· The new keyword can be avoided in instance creation

· Provides an alternative to Abstract Factory pattern

· Runtime specification of instance properties

· Reference of concrete class can be avoided

The associated source code contains the example we discussed.


2 Responses to “Prototype Pattern”

  1. Nice post. I recently posted about Prototype Design Pattern using Store creator as an example. Here is a link to my post

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s