[Factory method] - Add implementation of factory method.

Author: ivandrofly

Factory Method/Factory Method.csproj

@@ -42,12 +42,17 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Program.cs" />
+    <Compile Include="Program.RealWorldCode.cs" />
+    <Compile Include="Program.Structural.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
   </ItemGroup>
+  <ItemGroup>
+    <Content Include="factory.gif" />
+    <Content Include="Participants.txt" />
+  </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.

Factory Method/Participants.txt

@@ -0,0 +1,14 @@
+The classes and objects participating in this pattern are:
+
+Product  (Page)
+	defines the interface of objects the factory method creates
+
+ConcreteProduct  (SkillsPage, EducationPage, ExperiencePage)
+	implements the Product interface
+
+Creator  (Document)
+	declares the factory method, which returns an object of type Product. Creator may also define a default implementation of the factory method that returns a default ConcreteProduct object.
+	may call the factory method to create a Product object.
+
+ConcreteCreator  (Report, Resume)
+	overrides the factory method to return an instance of a ConcreteProduct.

Factory Method/Program.RealWorldCode.cs

@@ -0,0 +1,174 @@
+using System;
+using System.Collections.Generic;
+
+
+/// <summary>
+/// Creates an instance of several derived classes.
+/// 
+/// Define an interface for creating an object, but let subclasses decide which class to instantiate.
+/// Factory Method lets a class defer instantiation to subclasses.
+/// 
+/// Frequency of use: 5 high.
+/// </summary>
+namespace DoFactory.GangOfFour.Factory.RealWorld
+{
+    /// <summary>
+    /// MainApp startup class for Real-World 
+    /// Factory Method Design Pattern.
+    /// </summary>
+    class MainApp
+    {
+        /// <summary>
+        /// Entry point into console application.
+        /// </summary>
+        static void Main()
+        {
+            // Note: constructors call Factory Method
+            Document[] documents = new Document[2];
+
+            documents[0] = new Resume();
+            documents[1] = new Report();
+
+            // Display document pages
+            foreach (Document document in documents)
+            {
+                Console.WriteLine("\n" + document.GetType().Name + "--");
+                foreach (Page page in document.Pages)
+                {
+                    Console.WriteLine(" " + page.GetType().Name);
+                }
+            }
+
+            // Wait for user
+            Console.ReadKey();
+        }
+    }
+
+    /// <summary>
+    /// The 'Product' abstract class
+    /// </summary>
+    abstract class Page
+    {
+    }
+
+    /// <summary>
+    /// A 'ConcreteProduct' class
+    /// </summary>
+    class SkillsPage : Page
+    {
+    }
+
+    /// <summary>
+    /// A 'ConcreteProduct' class
+    /// </summary>
+    class EducationPage : Page
+    {
+    }
+
+    /// <summary>
+    /// A 'ConcreteProduct' class
+    /// </summary>
+    class ExperiencePage : Page
+    {
+    }
+
+    /// <summary>
+    /// A 'ConcreteProduct' class
+    /// </summary>
+    class IntroductionPage : Page
+    {
+    }
+
+    /// <summary>
+    /// A 'ConcreteProduct' class
+    /// </summary>
+    class ResultsPage : Page
+    {
+    }
+
+    /// <summary>
+    /// A 'ConcreteProduct' class
+    /// </summary>
+    class ConclusionPage : Page
+    {
+    }
+
+    /// <summary>
+    /// A 'ConcreteProduct' class
+    /// </summary>
+    class SummaryPage : Page
+    {
+    }
+
+    /// <summary>
+    /// A 'ConcreteProduct' class
+    /// </summary>
+    class BibliographyPage : Page
+    {
+    }
+
+    /// <summary>
+    /// The 'Creator' abstract class
+    /// </summary>
+    abstract class Document
+    {
+        private List<Page> _pages = new List<Page>();
+
+        // Constructor calls abstract Factory method
+        public Document()
+        {
+            this.CreatePages();
+        }
+
+        public List<Page> Pages
+        {
+            get { return _pages; }
+        }
+
+        // Factory Method
+        public abstract void CreatePages();
+    }
+
+    /// <summary>
+    /// A 'ConcreteCreator' class
+    /// </summary>
+    class Resume : Document
+    {
+        // Factory Method implementation
+        public override void CreatePages()
+        {
+            Pages.Add(new SkillsPage());
+            Pages.Add(new EducationPage());
+            Pages.Add(new ExperiencePage());
+        }
+    }
+
+    /// <summary>
+    /// A 'ConcreteCreator' class
+    /// </summary>
+    class Report : Document
+    {
+        // Factory Method implementation
+        public override void CreatePages()
+        {
+            Pages.Add(new IntroductionPage());
+            Pages.Add(new ResultsPage());
+            Pages.Add(new ConclusionPage());
+            Pages.Add(new SummaryPage());
+            Pages.Add(new BibliographyPage());
+        }
+    }
+}
+
+// Output:
+//Resume -------
+// SkillsPage
+// EducationPage
+// ExperiencePage
+
+//Report -------
+// IntroductionPage
+// ResultsPage
+// ConclusionPage
+// SummaryPage
+// BibliographyPage

Factory Method/Program.Structural.cs

@@ -0,0 +1,97 @@
+using System;
+
+/// <summary>
+/// Creates an instance of several derived classes.
+/// 
+/// Define an interface for creating an object, but let subclasses decide which class to instantiate.
+/// Factory Method lets a class defer instantiation to subclasses.
+/// 
+/// Frequency of use: 5 high.
+/// </summary>
+namespace DoFactory.GangOfFour.Factory.Structural
+{
+    /// <summary>
+    /// MainApp startup class for Structural 
+    /// Factory Method Design Pattern.
+    /// </summary>
+    class MainApp
+    {
+        /// <summary>
+        /// Entry point into console application.
+        /// </summary>
+        static void Main()
+        {
+            // An array of creators
+            Creator[] creators = new Creator[2];
+
+            creators[0] = new ConcreteCreatorA();
+            creators[1] = new ConcreteCreatorB();
+
+            // Iterate over creators and create products
+            foreach (Creator creator in creators)
+            {
+                Product product = creator.FactoryMethod();
+                Console.WriteLine("Created {0}",
+                  product.GetType().Name);
+            }
+
+            // Wait for user
+            Console.ReadKey();
+        }
+    }
+
+    /// <summary>
+    /// The 'Product' abstract class
+    /// </summary>
+    abstract class Product
+    {
+    }
+
+    /// <summary>
+    /// A 'ConcreteProduct' class
+    /// </summary>
+    class ConcreteProductA : Product
+    {
+    }
+
+    /// <summary>
+    /// A 'ConcreteProduct' class
+    /// </summary>
+    class ConcreteProductB : Product
+    {
+    }
+
+    /// <summary>
+    /// The 'Creator' abstract class
+    /// </summary>
+    abstract class Creator
+    {
+        public abstract Product FactoryMethod();
+    }
+
+    /// <summary>
+    /// A 'ConcreteCreator' class
+    /// </summary>
+    class ConcreteCreatorA : Creator
+    {
+        public override Product FactoryMethod()
+        {
+            return new ConcreteProductA();
+        }
+    }
+
+    /// <summary>
+    /// A 'ConcreteCreator' class
+    /// </summary>
+    class ConcreteCreatorB : Creator
+    {
+        public override Product FactoryMethod()
+        {
+            return new ConcreteProductB();
+        }
+    }
+}
+
+//Outputter:
+//Created ConcreteProductA
+//Created ConcreteProductB