Factory & Abstract factory

Author: Abhishek Kumar Singh

AbstractFactory.cs

@@ -0,0 +1,44 @@
+using System;
+
+namespace DesignPatterns.AbstractFactory
+{
+    // Abstract Products (2)
+    interface IPizza
+    {
+        string Eat();
+    }
+    interface IBurger
+    {
+        string Eat();
+    }
+
+    // Concrete Products
+    class VegPizza : IPizza
+    {
+        public string Eat()
+        {
+            return "Eating Veg Pizza";
+        }
+    }
+    class NonVegPizza : IPizza
+    {
+        public string Eat()
+        {
+            return "Eating Non-Veg Pizza";
+        }
+    }
+    class VegBurger : IBurger
+    {
+        public string Eat()
+        {
+            return "Eating Veg Burger";
+        }
+    }
+    class NonVegBurger : IBurger
+    {
+        public string Eat()
+        {
+            return "Eating Non-Veg Burger";
+        }
+    }
+}

AbstractFactory/Product.cs

@@ -0,0 +1,66 @@
+using DesignPatterns.Factory;
+
+namespace DesignPatterns.AbstractFactory
+{
+    //  Factory manages object creation logic in one place,
+    //  So the client code depends only on an interface/abstract class, not on concrete implementations.
+
+    // Abstract Factory
+    interface I_productFactory
+    {
+        IPizza PreparePizza();
+        IBurger PrepareBurger();
+    }
+
+    // Concrete Factories
+    class VegFactory : I_productFactory
+    {
+        public IPizza PreparePizza()
+        {
+            return new VegPizza();
+        }
+        public IBurger PrepareBurger()
+        {
+            return new VegBurger();
+        }
+    }
+
+    class NonVegFactory : I_productFactory
+    {
+        public IPizza PreparePizza()
+        {
+            return new NonVegPizza();
+        }
+        public IBurger PrepareBurger()
+        {
+            return new NonVegBurger();
+        }
+    }
+
+    // Factory Producer
+    internal class Service
+    {
+        private I_productFactory _product;
+        public Service(string type)
+        {
+            switch (type.ToUpper())
+            {
+                case "veg":
+                    _product = new VegFactory();
+                    break;
+                default:
+                    _product = new NonVegFactory();
+                    break;
+            }
+        }
+
+        public string GetPrizza()
+        {
+            return _product.PreparePizza().Eat();
+        }
+        public string GetBurger()
+        {
+            return _product.PrepareBurger().Eat();
+        }
+    }
+}

AbstractFactory/ProductAbstractFactory.cs

@@ -0,0 +1,16 @@
+using DesignPatterns.Factory;
+using System;
+
+namespace DesignPatterns.AbstractFactory
+{
+    internal class Program
+    {
+        static void Main(string[] args)
+        {
+            // Client does not know concrete implementations, only the Abstract Factory
+            Service service = new Service("veg");
+            Console.WriteLine(service.GetPrizza());
+            Console.WriteLine(service.GetBurger());
+        }
+    }
+}

AbstractFactory/Program.cs

@@ -33,7 +33,7 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <PropertyGroup>
-    <StartupObject>DesignPatterns.Factory.Program</StartupObject>
+    <StartupObject>DesignPatterns.AbstractFactory.Program</StartupObject>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
@@ -48,22 +48,23 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="AbstractFactory.cs" />
+    <Compile Include="AbstractFactory\Program.cs" />
+    <Compile Include="AbstractFactory\Product.cs" />
+    <Compile Include="AbstractFactory\ProductAbstractFactory.cs" />
     <Compile Include="Adapter\Adapter.cs" />
     <Compile Include="Adapter\MyLogger.cs" />
     <Compile Include="Adapter\Program.cs" />
     <Compile Include="Adapter\ThirdPartyLogger.cs" />
-    <Compile Include="Factory.cs" />
-    <Compile Include="Factory\VehicleFactory.cs" />
-    <Compile Include="Factory\Vehicle.cs" />
+    <Compile Include="Factory\ProductFactory.cs" />
+    <Compile Include="Factory\Product.cs" />
     <Compile Include="Factory\Program.cs" />
-    <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Singleton\Program.cs" />
     <Compile Include="Singleton\Singleton.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
 </Project>

DesignPatterns.csproj

@@ -0,0 +1,24 @@
+using System;
+
+namespace DesignPatterns.Factory
+{
+    // My Product
+    interface IPizza
+    {
+        void Eat();
+    }
+    internal class VegPizza : IPizza
+    {
+        public void Eat()
+        {
+            Console.WriteLine("Eating VegPizza...");
+        }
+    }
+    internal class NonVegPizza : IPizza
+    {
+        public void Eat()
+        {
+            Console.WriteLine("Eating NonVegPizza...");
+        }
+    }
+}

Factory.cs

@@ -2,25 +2,21 @@
 {
     //  Factory manages object creation logic in one place,
     //  So the client code depends only on an interface/abstract class, not on concrete implementations.
-    internal class VehicleFactory
+    internal class ProductFactory
     {
-        public static IVehicle GetVehicle(string type)
+        private static IPizza _pizza;
+        public static IPizza GetPizza(string type)
         {
-            IVehicle vehicle;
-
             switch(type.ToUpper())
             {
-                case "CAR":
-                    vehicle = new Car();
-                    break;
-                case "BIKE":
-                    vehicle = new Bike();
+                case "VEG":
+                    _pizza = new VegPizza();
                     break;
                 default:
-                    vehicle = new Truck();
+                    _pizza = new NonVegPizza();
                     break;
             }
-            return vehicle;
+            return _pizza;
         }
     }
 }