Prototype Design Pattern

The Prototype Design Pattern is a creational pattern. Its main idea is to create new objects by copying or cloning existing objects, rather than instantiating them directly. This is particularly useful when the creation of an object is costly or complex.

When to Use the Prototype Pattern?

When object creation is expensive or complex.
When you need to maintain object consistency.
When new object configurations are determined at runtime.

Key Features of the Prototype Pattern

Cloning Capability: Objects implement a cloning interface (e.g., ICloneable in C#).
Encapsulation: Encapsulates the logic for copying objects, avoiding reliance on external factories or constructors.
Dynamic Object Creation: Helps in situations where new types or configurations might emerge during runtime.

What are the Pros and Cons?

Pros

Reduces Initialization Overhead: Especially useful for expensive object creation processes.
Flexibility: Allows cloning objects with specific states or properties.
Avoids Subclassing Explosion: Reduces the need for numerous subclasses for slight variations of objects.

Cons

Complexity in Deep Cloning: Implementing deep clones can be challenging, especially for objects with nested references.
Unintended Side Effects: If not implemented carefully, cloning might lead to unintended consequences, like shared references.

Example: Bakery

Imagine you’re at a bakery that specializes in custom cakes. A popular cake design is frequently requested. Instead of making a new cake from scratch every time, the baker prepares a base cake (prototype) and customizes it as needed. This saves time and ensures consistency.

Class Diagram

Implementation in C#

Let’s implement the Prototype Design Pattern for vehicle construction in C#.

				
					public interface ICakePrototype
{
    ICakePrototype Clone();
}

public class CustomCake(string flavor, string frosting, string decorations) : ICakePrototype
{
    public string Flavor { get; set; } = flavor;
    public string Frosting { get; set; } = frosting;
    public string Decorations { get; set; } = decorations;

    /// <summary>
    /// Clone method implementation
    /// </summary>
    /// <returns></returns>
    public ICakePrototype Clone()
    {
        // Performs a shallow copy of the object
        return (ICakePrototype)this.MemberwiseClone();
    }

    /// <summary>
    /// For displaying cake details
    /// </summary>
    /// <returns></returns>
    public override string ToString()
    {
        return $"Cake with {Flavor} flavor, {Frosting} frosting, and decorated with {Decorations}.";
    }
}

// Main Program
class Program
{
    static void Main(string[] args)
    {
        // Create an original cake (the prototype)
        CustomCake prototypeCake = new("Vanilla", "Buttercream", "Sprinkles");
        
        Console.WriteLine("Prototype Cake: " + prototypeCake);
        
        // Clone the prototype and customize the copy
        CustomCake customCake = (CustomCake)prototypeCake.Clone();
        customCake.Decorations = "Chocolate Shavings"; // Customize decorations
        
        Console.WriteLine("Customized Cake: " + customCake);
        
        // Clone another cake with a different customization
        CustomCake anotherCake = (CustomCake)prototypeCake.Clone();
        anotherCake.Frosting = "Chocolate Ganache"; // Customize frosting
        
        Console.WriteLine("Another Customized Cake: " + anotherCake);
    }
}

Here is the output from the application

				
					Prototype Cake: Cake with Vanilla flavor, Buttercream frosting, and decorated with Sprinkles.
Customized Cake: Cake with Vanilla flavor, Buttercream frosting, and decorated with Chocolate Shavings.
Another Customized Cake: Cake with Vanilla flavor, Chocolate Ganache frosting, and decorated with Sprinkles.

Explanation of the Code

Prototype Interface (ICakePrototype): Ensures that all prototype classes implement the Clone method.
Concrete Prototype (CustomCake): Implements the prototype interface and provides the cloning logic using MemberwiseClone.
Demo (Program): Shows how a prototype object can be cloned and customized.

Sample Code

Summary

The Prototype Design Pattern is a powerful tool in your design arsenal, simplifying object creation while enabling dynamic and flexible workflows. Just like the bakery’s efficient process for customizing cakes, this pattern allows developers to reuse and adapt existing objects effortlessly.

When to Use the Prototype Pattern?

Key Features of the Prototype Pattern

What are the Pros and Cons?

Example: Bakery

Class Diagram

Implementation in C#

Explanation of the Code

Summary

Builder Design Pattern

Categories

Prototype Design Pattern

When to Use the Prototype Pattern?

Key Features of the Prototype Pattern

What are the Pros and Cons?

Example: Bakery

Class Diagram

Implementation in C#

Explanation of the Code

Summary

Builder Design Pattern

Categories

Tags