**Course Title:** Software Design Principles: Foundations and Best Practices **Section Title:** Design Patterns: Introduction and Creational Patterns **Topic:** Creational patterns: Singleton, Factory Method, Abstract Factory, Builder. **Introduction** In the realm of software design, creational patterns play a vital role in controlling object creation and promoting a better class structure. These patterns deal with how to create objects and the best practices to follow for that purpose. In this topic, we will delve into four essential creational patterns: Singleton, Factory Method, Abstract Factory, and Builder. Understanding these patterns is crucial to help you design robust, scalable, and maintainable software systems. ### 1. Singleton Pattern **Definition:** The Singleton pattern is a creational design pattern that restricts the instantiation of a class to a single instance. It ensures a class has only one instance, providing a global point of access to that instance. **Problem:** In many cases, you might want to control the instantiation of a class to ensure only one instance exists. This can be useful when dealing with resources that are expensive to create or when you want to share data across different parts of your application. **Solution:** The Singleton pattern offers a way to enforce a single instance by: * Creating a private constructor to prevent direct instantiation * Providing a static method or property to return the instance **Example:** Consider a logging mechanism where you want to write log messages to a single log file. ```csharp public sealed class Logger { // Private constructor private Logger() { } // Private static instance private static readonly Logger _instance = new Logger(); // Public static method to return the instance public static Logger Instance => _instance; // Logging method public void Log(string message) { Console.WriteLine($"Logging: {message}"); } } public class Program { public static void Main() { Logger.Instance.Log("Program started."); Logger.Instance.Log("Program ended."); } } ``` **Practical Takeaway:** Use the Singleton pattern when you need to ensure a class has only one instance and control the instantiation process. However, be cautious when using this pattern, as it can introduce global state and make your code harder to test. ### 2. Factory Method Pattern **Definition:** The Factory Method pattern is a creational design pattern that provides an interface for creating objects, letting subclasses decide which class to instantiate. **Problem:** In object-oriented programming, you may encounter situations where you need to create objects without knowing their exact class until runtime. **Solution:** The Factory Method pattern solves this problem by: * Defining an interface or base class for object creation * Providing a method that returns the created object * Allowing subclasses to override the method to instantiate the desired class **Example:** Suppose you're building an e-commerce application with different payment gateways (e.g., PayPal, Stripe, or Bank Transfer). ```csharp public abstract class PaymentGateway { public abstract void ProcessPayment(); } public class PayPal : PaymentGateway { public override void ProcessPayment() { Console.WriteLine("Processing payment through PayPal."); } } public class Stripe : PaymentGateway { public override void ProcessPayment() { Console.WriteLine("Processing payment through Stripe."); } } public abstract class PaymentFactory { public abstract PaymentGateway GetPaymentGateway(); } public class PayPalFactory : PaymentFactory { public override PaymentGateway GetPaymentGateway() { return new PayPal(); } } public class StripeFactory : PaymentFactory { public override PaymentGateway GetPaymentGateway() { return new Stripe(); } } public class Program { public static void Main() { PaymentFactory factory = new PayPalFactory(); PaymentGateway gateway = factory.GetPaymentGateway(); gateway.ProcessPayment(); } } ``` **Practical Takeaway:** Use the Factory Method pattern when you need to decouple object creation from specific classes and allow subclasses to decide which class to instantiate. ### 3. Abstract Factory Pattern **Definition:** The Abstract Factory pattern is a creational design pattern that provides a way to encapsulate a group of individual factories, allowing you to create families of related objects without specifying their concrete classes. **Problem:** When developing complex systems with interdependent components, you might need to create multiple objects that work together and share some common characteristic. **Solution:** The Abstract Factory pattern addresses this issue by: * Defining an interface or base class for families of related objects * Providing a class that returns the related objects **Example:** Let's consider a UI component library that provides different sets of GUI elements (e.g., buttons, text boxes, or checkboxes). ```csharp public abstract class Button { public abstract void Paint(); } public abstract class TextBox { public abstract void Edit(); } public abstract class CheckBox { public abstract void Check(); } public abstract class GUIFactory { public abstract Button CreateButton(); public abstract TextBox CreateTextBox(); public abstract CheckBox CreateCheckBox(); } public class MacGUIFactory : GUIFactory { public override Button CreateButton() { return new MacButton(); } public override TextBox CreateTextBox() { return new MacTextBox(); } public override CheckBox CreateCheckBox() { return new MacCheckBox(); } } public class WindowsGUIFactory : GUIFactory { public override Button CreateButton() { return new WindowsButton(); } public override TextBox CreateTextBox() { return new WindowsTextBox(); } public override CheckBox CreateCheckBox() { return new WindowsCheckBox(); } } public class MacButton : Button { public override void Paint() { Console.WriteLine("Painting a button on a Mac."); } } public class MacTextBox : TextBox { public override void Edit() { Console.WriteLine("Editing a text box on a Mac."); } } public class MacCheckBox : CheckBox { public override void Check() { Console.WriteLine("Checking a checkbox on a Mac."); } } public class WindowsButton : Button { public override void Paint() { Console.WriteLine("Painting a button on Windows."); } } public class WindowsTextBox : TextBox { public override void Edit() { Console.WriteLine("Editing a text box on Windows."); } } public class WindowsCheckBox : CheckBox { public override void Check() { Console.WriteLine("Checking a checkbox on Windows."); } } public class Program { public static void Main() { GUIFactory factory = new MacGUIFactory(); Button button = factory.CreateButton(); TextBox textBox = factory.CreateTextBox(); CheckBox checkBox = factory.CreateCheckBox(); button.Paint(); textBox.Edit(); checkBox.Check(); } } ``` **Practical Takeaway:** Use the Abstract Factory pattern when you need to encapsulate families of related objects that work together and share some common characteristic, without specifying their concrete classes. ### 4. Builder Pattern **Definition:** The Builder pattern is a creational design pattern that separates the construction of complex objects from their representation. **Problem:** When building complex objects, you might need to perform many steps to construct the desired object, which can lead to overbearing methods and a rigid design. **Solution:** The Builder pattern solves this issue by: * Defining a class for the object being built (usually with a simple constructor) * Providing a class to construct the object (usually with a complex constructor) **Example:** Let's consider building a complex object such as a house. ```csharp public class House { public string Address { get; set; } public int NumberOfFloors { get; set; } public string RoofType { get; set; } public string WallType { get; set; } public void Build() { Console.WriteLine($"House is built: {Address}"); } } public abstract class HouseBuilder { protected House house; public HouseBuilder() { house = new House(); } public HouseBuilder SetAddress(string address) { house.Address = address; return this; } public HouseBuilder SetNumberOfFloors(int numberOfFloors) { house.NumberOfFloors = numberOfFloors; return this; } public abstract HouseBuilder SetRoofType(string roofType); public abstract HouseBuilder SetWallType(string wallType); public abstract House Build(); } public class ModernHouseBuilder : HouseBuilder { public override HouseBuilder SetRoofType(string roofType) { house.RoofType = "Metal"; return this; } public override HouseBuilder SetWallType(string wallType) { house.WallType = "Brick"; return this; } public override House Build() { house.Build(); return house; } } public class Program { public static void Main() { ModernHouseBuilder builder = new ModernHouseBuilder(); House house = builder.SetAddress("123, Main St") .SetNumberOfFloors(3) .SetRoofType("none") .SetWallType("none") .Build(); } } ``` **Practical Takeaway:** Use the Builder pattern when you need to separate the construction of complex objects from their representation, providing a flexible and step-by-step object construction process. ### Conclusion Creational patterns offer essential tools for controlling object creation, promoting better class structure, and ensuring that your software system is robust, scalable, and maintainable. Understanding the Singleton, Factory Method, Abstract Factory, and Builder patterns allows you to: * Control instance creation with the Singleton pattern * Decouple object creation with the Factory Method pattern * Encapsulate families of related objects with the Abstract Factory pattern * Separate complex object construction with the Builder pattern By mastering these creational patterns, you can improve your software design skills and tackle complex problems with confidence.