Factory Method Pattern

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

1. Encapsulation of Object Creation: The creation logic is encapsulated within a factory method.
2. Loose Coupling: Clients only depend on the interface or abstract class, not the concrete implementations.
3. 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

1. The client code (Main method) works with an abstract factory (NotificationFactory) and does not depend on the specific classes (EmailNotification or SmsNotification).
2. 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.