Advertisement
Guest User

Untitled

a guest
Jun 20th, 2019
100
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 5.20 KB | None | 0 0
  1. using System;
  2. using System.Collections.Generic;
  3.  
  4. namespace builder
  5. {
  6. /// <summary>
  7. /// MainApp startup class for .NET optimized
  8. /// Builder Design Pattern.
  9. /// </summary>
  10. public class MainApp
  11. {
  12. /// <summary>
  13. /// Entry point into console application.
  14. /// </summary>
  15. public static void Main()
  16. {
  17. // Create shop
  18. var shop = new Shop();
  19.  
  20. // Construct and display vehicles
  21. shop.Construct(new ScooterBuilder());
  22. shop.ShowVehicle();
  23.  
  24. shop.Construct(new CarBuilder());
  25. shop.ShowVehicle();
  26.  
  27. shop.Construct(new MotorCycleBuilder());
  28. shop.ShowVehicle();
  29.  
  30. // Wait for user
  31. Console.ReadKey();
  32. }
  33. }
  34.  
  35. /// <summary>
  36. /// The 'Director' class
  37. /// </summary>
  38. class Shop
  39. {
  40. private VehicleBuilder _vehicleBuilder;
  41.  
  42. // Builder uses a complex series of steps
  43. public void Construct(VehicleBuilder vehicleBuilder)
  44. {
  45. _vehicleBuilder = vehicleBuilder;
  46.  
  47. _vehicleBuilder.BuildFrame();
  48. _vehicleBuilder.BuildEngine();
  49. _vehicleBuilder.BuildWheels();
  50. _vehicleBuilder.BuildDoors();
  51. }
  52.  
  53. public void ShowVehicle()
  54. {
  55. _vehicleBuilder.Vehicle.Show();
  56. }
  57. }
  58.  
  59. /// <summary>
  60. /// The 'Builder' abstract class
  61. /// </summary>
  62. abstract class VehicleBuilder
  63. {
  64. public Vehicle Vehicle { get; private set; }
  65.  
  66. // Constructor
  67. public VehicleBuilder(VehicleType vehicleType)
  68. {
  69. Vehicle = new Vehicle(vehicleType);
  70. }
  71.  
  72. public abstract void BuildFrame();
  73. public abstract void BuildEngine();
  74. public abstract void BuildWheels();
  75. public abstract void BuildDoors();
  76. }
  77.  
  78. /// <summary>
  79. /// The 'ConcreteBuilder1' class
  80. /// </summary>
  81. class MotorCycleBuilder : VehicleBuilder
  82. {
  83. // Invoke base class constructor
  84. public MotorCycleBuilder()
  85. : base(VehicleType.MotorCycle)
  86. {
  87. }
  88.  
  89. public override void BuildFrame()
  90. {
  91. Vehicle[PartType.Frame] = "MotorCycle Frame";
  92. }
  93.  
  94. public override void BuildEngine()
  95. {
  96. Vehicle[PartType.Engine] = "500 cc";
  97. }
  98.  
  99. public override void BuildWheels()
  100. {
  101. Vehicle[PartType.Wheel] = "2";
  102. }
  103.  
  104. public override void BuildDoors()
  105. {
  106. Vehicle[PartType.Door] = "0";
  107. }
  108. }
  109.  
  110. /// <summary>
  111. /// The 'ConcreteBuilder2' class
  112. /// </summary>
  113. class CarBuilder : VehicleBuilder
  114. {
  115. // Invoke base class constructor
  116. public CarBuilder()
  117. : base(VehicleType.Car)
  118. {
  119. }
  120.  
  121. public override void BuildFrame()
  122. {
  123. Vehicle[PartType.Frame] = "Car Frame";
  124. }
  125.  
  126. public override void BuildEngine()
  127. {
  128. Vehicle[PartType.Engine] = "2500 cc";
  129. }
  130.  
  131. public override void BuildWheels()
  132. {
  133. Vehicle[PartType.Wheel] = "4";
  134. }
  135.  
  136. public override void BuildDoors()
  137. {
  138. Vehicle[PartType.Door] = "4";
  139. }
  140. }
  141.  
  142. /// <summary>
  143. /// The 'ConcreteBuilder3' class
  144. /// </summary>
  145. class ScooterBuilder : VehicleBuilder
  146. {
  147. // Invoke base class constructor
  148. public ScooterBuilder() : base(VehicleType.Scooter)
  149. {
  150. }
  151.  
  152. public override void BuildFrame()
  153. {
  154. Vehicle[PartType.Frame] = "Scooter Frame";
  155. }
  156.  
  157. public override void BuildEngine()
  158. {
  159. Vehicle[PartType.Engine] = "50 cc";
  160. }
  161.  
  162. public override void BuildWheels()
  163. {
  164. Vehicle[PartType.Wheel] = "2";
  165. }
  166.  
  167. public override void BuildDoors()
  168. {
  169. Vehicle[PartType.Door] = "0";
  170. }
  171. }
  172.  
  173. /// <summary>
  174. /// The 'Product' class
  175. /// </summary>
  176. class Vehicle
  177. {
  178. private VehicleType _vehicleType;
  179. private Dictionary<PartType, string> _parts = new Dictionary<PartType, string>();
  180.  
  181. // Constructor
  182. public Vehicle(VehicleType vehicleType)
  183. {
  184. _vehicleType = vehicleType;
  185. }
  186.  
  187. public string this[PartType key]
  188. {
  189. get { return _parts[key]; }
  190. set { _parts[key] = value; }
  191. }
  192.  
  193. public void Show()
  194. {
  195. Console.WriteLine("\n---------------------------");
  196. Console.WriteLine("Vehicle Type: {0}", _vehicleType);
  197. Console.WriteLine(" Frame : {0}",
  198. this[PartType.Frame]);
  199. Console.WriteLine(" Engine : {0}",
  200. this[PartType.Engine]);
  201. Console.WriteLine(" #Wheels: {0}",
  202. this[PartType.Wheel]);
  203. Console.WriteLine(" #Doors : {0}",
  204. this[PartType.Door]);
  205. }
  206. }
  207.  
  208. /// <summary>
  209. /// Part type enumeration
  210. /// </summary>
  211. public enum PartType
  212. {
  213. Frame,
  214. Engine,
  215. Wheel,
  216. Door
  217. }
  218.  
  219. /// <summary>
  220. /// Vehicle type enumeration
  221. /// </summary>
  222. public enum VehicleType
  223. {
  224. Car,
  225. Scooter,
  226. MotorCycle
  227. }
  228. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement