.NET Design Patterns

Prototype


 Definition
 UML diagram
 Participants
 Structural code in C#
 Real-world code in C#
 .NET Optimized code in C#



Definition

Specify the kind of objects to create using a prototypical instance, and create new objects by copying this prototype.

Frequency of use:
Medium




UML class diagram






Participants


    The classes and objects participating in this pattern are:

  • Prototype  (ColorPrototype)
    • declares an interface for cloning itself
  • ConcretePrototype  (Color)
    • implements an operation for cloning itself
  • Client  (ColorManager)
    • creates a new object by asking a prototype to clone itself



Structural code in C#


This structural code demonstrates the Prototype pattern in which new objects are created by copying pre-existing objects (prototypes) of the same class.

                 

using System;

 

namespace DoFactory.GangOfFour.Prototype.Structural

{

  /// <summary>

  /// MainApp startup class for Structural

  /// Prototype Design Pattern.

  /// </summary>

  class MainApp

  {

    /// <summary>

    /// Entry point into console application.

    /// </summary>

    static void Main()

    {

      // Create two instances and clone each

 

      ConcretePrototype1 p1 = new ConcretePrototype1("I");

      ConcretePrototype1 c1 = (ConcretePrototype1)p1.Clone();

      Console.WriteLine("Cloned: {0}", c1.Id);

 

      ConcretePrototype2 p2 = new ConcretePrototype2("II");

      ConcretePrototype2 c2 = (ConcretePrototype2)p2.Clone();

      Console.WriteLine("Cloned: {0}", c2.Id);

 

      // Wait for user

      Console.ReadKey();

    }

  }

 

  /// <summary>

  /// The 'Prototype' abstract class

  /// </summary>

  abstract class Prototype

  {

    private string _id;

 

    // Constructor

    public Prototype(string id)

    {

      this._id = id;

    }

 

    // Gets id

    public string Id

    {

      get { return _id; }

    }

 

    public abstract Prototype Clone();

  }

 

  /// <summary>

  /// A 'ConcretePrototype' class

  /// </summary>

  class ConcretePrototype1 : Prototype

  {

    // Constructor

    public ConcretePrototype1(string id)

      : base(id)

    {

    }

 

    // Returns a shallow copy

    public override Prototype Clone()

    {

      return (Prototype)this.MemberwiseClone();

    }

  }

 

  /// <summary>

  /// A 'ConcretePrototype' class

  /// </summary>

  class ConcretePrototype2 : Prototype

  {

    // Constructor

    public ConcretePrototype2(string id)

      : base(id)

    {

    }

 

    // Returns a shallow copy

    public override Prototype Clone()

    {

      return (Prototype)this.MemberwiseClone();

    }

  }

}


Output
Cloned: I
Cloned: II




Real-world code in C#


This real-world code demonstrates the Prototype pattern in which new Color objects are created by copying pre-existing, user-defined Colors of the same type.

                 

using System;

using System.Collections.Generic;

 

namespace DoFactory.GangOfFour.Prototype.RealWorld

{

  /// <summary>

  /// MainApp startup class for Real-World

  /// Prototype Design Pattern.

  /// </summary>

  class MainApp

  {

    /// <summary>

    /// Entry point into console application.

    /// </summary>

    static void Main()

    {

      ColorManager colormanager = new ColorManager();

 

      // Initialize with standard colors

      colormanager["red"] = new Color(255, 0, 0);

      colormanager["green"] = new Color(0, 255, 0);

      colormanager["blue"] = new Color(0, 0, 255);

 

      // User adds personalized colors

      colormanager["angry"] = new Color(255, 54, 0);

      colormanager["peace"] = new Color(128, 211, 128);

      colormanager["flame"] = new Color(211, 34, 20);

 

      // User clones selected colors

      Color color1 = colormanager["red"].Clone() as Color;

      Color color2 = colormanager["peace"].Clone() as Color;

      Color color3 = colormanager["flame"].Clone() as Color;

 

      // Wait for user

      Console.ReadKey();

    }

  }

 

  /// <summary>

  /// The 'Prototype' abstract class

  /// </summary>

  abstract class ColorPrototype

  {

    public abstract ColorPrototype Clone();

  }

 

  /// <summary>

  /// The 'ConcretePrototype' class

  /// </summary>

  class Color : ColorPrototype

  {

    private int _red;

    private int _green;

    private int _blue;

 

    // Constructor

    public Color(int red, int green, int blue)

    {

      this._red = red;

      this._green = green;

      this._blue = blue;

    }

 

    // Create a shallow copy

    public override ColorPrototype Clone()

    {

      Console.WriteLine(

        "Cloning color RGB: {0,3},{1,3},{2,3}",

        _red, _green, _blue);

 

      return this.MemberwiseClone() as ColorPrototype;

    }

  }

 

  /// <summary>

  /// Prototype manager

  /// </summary>

  class ColorManager

  {

    private Dictionary<string, ColorPrototype> _colors =

      new Dictionary<string, ColorPrototype>();

 

    // Indexer

    public ColorPrototype this[string key]

    {

      get { return _colors[key]; }

      set { _colors.Add(key, value); }

    }

  }

}


Output
Cloning color RGB: 255,  0,  0
Cloning color RGB: 128,211,128
Cloning color RGB: 211, 34, 20




.NET Optimized code in C#


The .NET optimized code demonstrates the same real-world situation as above but uses modern, built-in .NET features, such as, generics, reflection, object initializers, automatic properties, etc. You can find an example on our Singleton pattern page.

All other patterns (and much more) are available in our .NET Design Pattern Framework 4.5.


Not only does the .NET Design Pattern Framework 4.5 cover GOF and Enterprise patterns, it also includes .NET pattern architectures that reduce the code you need to write by up to 75%. This unique package will change your .NET lifestyle -- for only $79.  Here's what is included:



  • 69 gang-of-four pattern projects
  • 46 head-first pattern projects
  • Fowler's enterprise patterns
  • Multi-tier patterns
  • Convention over configuration
  • Active Record and CQRS patterns
  • Repository and Unit-of-Work patterns
  • MVC, MVP, & MVVM patterns
  • REST patterns with Web API
  • SparkTM Rapid App Dev (RAD) platform!
  • Art Shop MVC Reference Application
  • 100% pure source code