C# | Prototype Design Pattern | Creational Design Pattern

Prototype pattern refers to creating duplicate object while keeping performance in mind. This type of design pattern comes under creational pattern as this pattern provides one of the best ways to create an object.

This pattern involves implementing a prototype interface which tells to create a clone of the current object. This pattern is used when creation of object directly is costly. 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.

Code Syntax-

/// <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);

    }

}

----------------------------------------------------Program Class---------------------------------------------------    

internal 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 = "Arun"; //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();

    }

}


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.


Comments

Post a Comment

Popular posts from this blog

C# | SOLID Principles

Image
  SOLID stands for: S = Single Responsibility Principle O = Open/Closed Principle L = Liskov Substitution Principle I = Interface Segregation Principle D = Dependency Inversion Principle Solid Principles Single Responsibility Principle Each software module should have one and only one reason to change. The Single Responsibility Principle is the first principle of SOLID principles. It is the fundamental principle of object-oriented programming that determines how we should design classes. The Single Responsibility Principle states that: Each software module should have one and only one reason to change. In other words, a class should have only one responsibility and therefore it should have only one reason to change its code. If a class has more than one responsibility, then there will be more than one reason to change the class (code). Now, the question is what is responsibility? An application can have many functionalities (features). For example, an online e-commerce application ...
Read more

C# | Design Patterns

Image
Design patterns provide general solutions or a flexible way to solve common design problems. This article introduces design patterns and how design patterns are implemented in C# and .NET. Before starting with design patterns in .NET, let's understand the meaning of design patterns and why they are useful in software architecture and programming. What are Design Patterns in Software Development? Design Patterns in the object-oriented world are a reusable solution to common software design problems that repeatedly occur in real-world application development. It is a template or description of how to solve problems that can be used in many situations. " A pattern is a recurring solution to a problem in a context. " " Each pattern describes a problem that occurs over and over again in our environment and then describes the core of the solution to that problem in such a way that you can use this solution a million times over without ever doing it the same way twice. ...
Read more