Factory Method Pattern

Question

Can anyone explain Factory Method Pattern

Jaish Mathews · Answer

The Factory Method Pattern is a creational design pattern that provides an interface for creating objects but allows subclasses to alter the type of objects that will be created. It helps to encapsulate the object creation process and promotes code flexibility and reusability. Key Characteristics Encapsulation of Object Creation : The creation logic is encapsulated within a factory method. Loose Coupling : Clients only depend on the interface or abstract class not the concrete implementations. Single Responsibility Principle : The creation of objects is separated from the use of objects. C# Example: Factory Method Pattern Scenario : Notification Sender Let's say we have a notification system that supports different notification types: Email and SMS. Step 1: Define a Product Interface public interface INotification { void Notify(string message); } Step 2: Create Concrete Implementations public class EmailNotification : INotification { public void Notify(string message) { Console.WriteLine($Email Notification: {message}); } } public class SmsNotification : INotification { public void Notify(string message) { Console.WriteLine($SMS Notification: {message}); } } Step 3: Define the Creator (Abstract Class) The creator declares the factory method which returns an object of type INotification . public abstract class NotificationFactory { public abstract INotification CreateNotification(); } Step 4: Create Concrete Factories Concrete factories override the factory method to specify the type of object to be created. public class EmailNotificationFactory : NotificationFactory { public override INotification CreateNotification() { return new EmailNotification(); } } public class SmsNotificationFactory : NotificationFactory { public override INotification CreateNotification() { return new SmsNotification(); } } Step 5: Client Code The client interacts with the factory instead of directly instantiating the objects. class Program { static void Main(string[] args) { NotificationFactory factory; // Email Notification factory = new EmailNotificationFactory(); var emailNotifier = factory.CreateNotification(); emailNotifier.Notify(This is an email notification.); // SMS Notification factory = new SmsNotificationFactory(); var smsNotifier = factory.CreateNotification(); smsNotifier.Notify(This is an SMS notification.); } } How It Works The client code ( Main method) works with an abstract factory ( NotificationFactory ) and does not depend on the specific classes ( EmailNotification or SmsNotification ). The concrete factories ( EmailNotificationFactory and SmsNotificationFactory ) encapsulate the object creation process. Output Email Notification: This is an email notification. SMS Notification: This is an SMS notification. Advantages Promotes loose coupling between client code and object creation logic. Easy to introduce new types by adding new factories. Follows the Open/Closed Principle (open for extension closed for modification). Disadvantages Can lead to a proliferation of classes as each new product requires a new factory. Adds complexity compared to directly instantiating objects. This pattern is widely used in scenarios like logging frameworks database connections and notification systems where the type of object created needs to be dynamic.

Rajeesh Menoth · Answer

Hi The class to instantiate objects without specifying the exact class of the object that will be created. Overall this promotes loose coupling to the Open/Closed Principle (open for extension closed for modification). Sangeetha has already covered the details of the components so I won't repeat that information here. You can go through some of the example articles - https://www.geeksforgeeks.org/factory-method-for-designing-pattern/ https://www.c-sharpcorner.com/blogs/factory-design-pattern-in-c-sharp

Sangeetha S · Answer

The Factory Method Pattern is a creational design pattern used in object-oriented programming. Its main purpose is to define an interface for creating an object but allow subclasses to alter the type of objects that will be created. Here's a quick breakdown: Creator : An interface or abstract class that declares the factory method. It may also provide some default implementation for this method. Concrete Creator : A class that implements the factory method to return an instance of a specific product. Product : An interface or abstract class representing the objects created by the factory method. Concrete Product : The classes that implement the Product interface representing the specific objects that can be created. Benefits: Decouples Code : The client code doesn't need to know the specifics of the object creation leading to less coupling. Flexibility : You can introduce new products without altering the existing codebase adhering to the Open/Closed Principle. Encapsulation : It encapsulates the instantiation process allowing for better management of object creation