Design Pattern For Beginner- Part-3: Prototype Design Pattern

using System;  
using System.Collections;  
using System.Globalization;  
namespace Test1  
{  
    class Test  
    {  
        public string Name;  
    }  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Test obj1 = new Test();  
            obj1.Name = "sourav";  
            Test obj2 = obj1; // Trying to make copy in obj2  
            obj2.Name = "c-sharpcorner.com";  
            Console.WriteLine(obj1.Name);  
            Console.ReadLine();  
        }  
    }  
} 

And we think that one copy of obj1 is getting stored in obj2. But due to the primary concept of the object being a reference type, in other words, if we initialize one object to another, they both point to the exact memory location where the actual value is present.

Now the next line is the most interesting. Here we will see the concept behind the screen. We are initializing a property (data member) of obj2. When we initialize obj1 to obj2, then both are.

They both point to the same memory location. (Generally, in heap memory and obj1 and obj2 are created on the top of the stack.) In the next line, when we set the property of obj2, it automatically reflected obj1. And that is the reason why, when we are trying to print the property of obj1 (initialized to "Sourav"), we are getting the value of obj2 (c-sharpcorner.com).

Now, this is the problem, and we are sure that, in this example, not all objects are created from the exact copy. Then what is the solution?

Let's use MemberwiseClone() function

.Yes, this is the solution. In the following example, we will see how to implement the MemberwiseClone() function to copy the same object to another object.

using System;  
using System.Collections;  
using System.Globalization;  
namespace Test1  
{  
    class Test  
    {  
        public string Name;  
        public Test CloneMe(Test t)  
        {  
            return (Test)this.MemberwiseClone();  
        }  
    }  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Test obj1 = new Test();  
            obj1.Name = "sourav";  
            Test obj2 = obj1.CloneMe(obj1); // Trying to make copy in obj2  
            obj2.Name = "c-sharpcorner.com";  
            Console.WriteLine(obj1.Name);  
            Console.ReadLine();  
        }  
    }  
} 

Here is the output.

Oh! At last, we have found the right solution to make a copy of the object. And this is an example of the Prototype Design Pattern.

Hmm...Okay, you are thinking, "I understood the Prototype pattern, but the example is meaningless." (If you want to hear it, please visit here.) dear reader, I did not forget the promise I made in my first article of the Design Pattern Series.

Let's talk about a scenario where the Prototype Design Pattern is relevant.

Consider that you want to create one copy of an object multiple times. For your birthday, you want to send an invitation letter to your friends; now, the content and sender name will remain the same, whereas the recipient name will only change. In this situation, we can use a prototype of the invitation card for multiple friends.

Take another example where one object will be created after heavy database operations (as we know, database operations are very costly), and we want that object 100 times. What if we make a clone of the same object by the Prototype Desing Pattern rather than hitting the database 100 times? Good solution, right?

Ok, I am talking too much. Let's implement our first scenario in C# code. Here is the sample code.

And here is the output of what we expected.

(Guys, believe me, or not. I am writing this article, and it's 23:50; in other words, it is 11.50 PM, and in 10 minutes, it's my birthday on 8-8-2013).

Now think about my crazy friend (the Tattoo fellow). He has a few hundred friends and wants to ask them all. If we use the Factory Design Pattern and give him one application, we hope his problem is solved. And here, for the sake of simplicity of the example, we have invited only five friends.

Conclusion

This article taught us about one more pervasive design pattern called the "Prototype Design Pattern."

Continue Learning

• Design Pattern For Beginners - Part 4: Decorator Design Pattern
• Design Pattern For Beginners - Part 5: Composite Design Pattern
• Design Pattern For Beginners - Part 6: Adaptor Design Pattern
• Design Pattern For Beginners - Part 7: Bridge Design Pattern
• Design Pattern For Beginners - Part 8: memento Design Pattern
• Design Pattern for Beginners - Part-9: Strategy Design Pattern
• Design Pattern for Beginners - Part-10: Observer Design Pattern
• Design Pattern For Beginners - Part 11: Implement Decouple Classes in Application