What is the Factory Method Pattern?

The Factory Method pattern is a creational design pattern that defines an interface for creating objects, but lets subclasses decide which class to instantiate. This approach encapsulates the object creation logic, promoting loose coupling and making your code more flexible and scalable.

🏗 Common Use Cases

• UI Component Libraries – Dynamically create different types of UI elements based on context.
• Document Generation – Produce various document types (PDF, Word, HTML) from a common interface.
• Game Development – Generate different enemy types or game objects at runtime.
• Data Parsers – Create specific parsers for varying file formats without changing the core processing logic.

When Should You Avoid Factory Method?

While the Factory Method pattern provides great flexibility, it might not always be the best choice:

❌ Over-Engineering – If object creation is straightforward, introducing extra layers can add unnecessary complexity.
❌ Class Proliferation – Excessive use can lead to many small classes, making the codebase harder to navigate.
❌ Simple Instantiation – When dependency injection or direct instantiation would suffice, the added indirection may not be justified.

---

Implementing Factory Method in C#

Imagine you’re developing a game where you need to spawn different types of enemies. We’ll define a common enemy interface, then use an abstract spawner that employs a factory method to produce specific enemy types.

// Enemy interface
public interface IEnemy
{
    void Attack();
    string GetName();
}

// Concrete Enemy: Zombie
public class Zombie : IEnemy
{
    public void Attack()
    {
        Console.WriteLine("Zombie attacks with a vicious bite!");
    }

    public string GetName()
    {
        return "Zombie";
    }
}

// Concrete Enemy: Vampire
public class Vampire : IEnemy
{
    public void Attack()
    {
        Console.WriteLine("Vampire attacks with a draining bite!");
    }

    public string GetName()
    {
        return "Vampire";
    }
}

// The abstract Spawner class declares the factory method.
public abstract class EnemySpawner
{
    // Factory Method: Subclasses decide which enemy to instantiate.
    public abstract IEnemy SpawnEnemy();

    // A common operation that uses the enemy.
    public void EngageEnemy()
    {
        IEnemy enemy = SpawnEnemy();
        Console.WriteLine($"Engaging a {enemy.GetName()}!");
        enemy.Attack();
    }
}

// Concrete Spawner for Zombies
public class ZombieSpawner : EnemySpawner
{
    public override IEnemy SpawnEnemy()
    {
        return new Zombie();
    }
}

// Concrete Spawner for Vampires
public class VampireSpawner : EnemySpawner
{
    public override IEnemy SpawnEnemy()
    {
        return new Vampire();
    }
}

You can now create a spawner for each enemy type and engage them:

EnemySpawner zombieSpawner = new ZombieSpawner();
zombieSpawner.EngageEnemy();

EnemySpawner vampireSpawner = new VampireSpawner();
vampireSpawner.EngageEnemy();

In the console output, you’ll see the respective enemy types being spawned and engaged.

---

Final Thoughts

The Factory Method pattern is a powerful tool for creating objects in a flexible and scalable way. By delegating the instantiation logic to subclasses, you can easily extend and customize your object creation process without modifying existing code.

When designing with the Factory Method pattern, remember to keep your interfaces simple and focused on a single responsibility. This will make your codebase easier to maintain and extend as your project grows.