Add implementation of Prototype DP.

Author: ivandrofly

Prototype/Participants.txt

@@ -0,0 +1,10 @@
+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

Prototype/Program.RealWorldCode.cs

@@ -0,0 +1,96 @@
+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

Prototype/Program.StructuralCode.cs

@@ -0,0 +1,102 @@
+using System;
+
+/// <summary>
+///A fully initialized instance to be copied or cloned
+///
+/// Specify the kind of objects to create using a prototypical instance,
+/// and create new objects by copying this prototype.
+/// 
+/// Frequency of use: 3 Medium.
+/// </summary>
+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

Prototype/Program.cs

@@ -42,12 +42,17 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Program.cs" />
+    <Compile Include="Program.RealWorldCode.cs" />
+    <Compile Include="Program.StructuralCode.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
   </ItemGroup>
+  <ItemGroup>
+    <Content Include="Participants.txt" />
+    <Content Include="prototype.gif" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.