Understanding the Factory Pattern in .NET Core

In the world of software design, the Factory Pattern stands as a powerful tool within the creational design patterns arsenal. It provides a clean and flexible way to create objects, allowing a class to delegate the responsibility of instantiation to its subclasses. In this article, we'll explore the Factory Pattern through a real-world example in the context of a car manufacturing system, demonstrating its application using .NET Core.

Factory pattern in .NET Core

The Factory Pattern falls under the creational design patterns category and revolves around the concept of creating objects. It introduces an interface for creating objects but allows subclasses to alter the type of objects that will be created. This pattern promotes code flexibility, maintainability, and scalability by centralizing the object creation process.

Real-world Example: Car Manufacturing

Consider a scenario where you are tasked with designing a system for a car manufacturing company. Cars consist of various components like engines, wheels, and interiors, and each car model may have unique specifications for these components.

Step 1. Define the Product Interface (CarPart).

public interface ICarPart
{
    string GetDescription();
}

Step 2. Create Concrete Product Classes (Engine, Wheel, Interior).

public class Engine : ICarPart
{
    public string GetDescription()
    {
        return "Engine: High-performance engine";
    }
}

public class Wheel : ICarPart
{
    public string GetDescription()
    {
        return "Wheel: Alloy wheels";
    }
}

public class Interior : ICarPart
{
    public string GetDescription()
    {
        return "Interior: Leather seats and advanced infotainment system";
    }
}

Step 3. Create the Creator (CarPartFactory).

public abstract class CarPartFactory
{
    public abstract ICarPart CreateCarPart();
}

Step 4. Implement Concrete Creator Classes (HighPerformanceEngineFactory, AlloyWheelFactory, LuxuryInteriorFactory).

public class HighPerformanceEngineFactory : CarPartFactory
{
    public override ICarPart CreateCarPart()
    {
        return new Engine();
    }
}

public class AlloyWheelFactory : CarPartFactory
{
    public override ICarPart CreateCarPart()
    {
        return new Wheel();
    }
}

public class LuxuryInteriorFactory : CarPartFactory
{
    public override ICarPart CreateCarPart()
    {
        return new Interior();
    }
}

Step 5. Client Code - Assembling a Car.

class Program
{
    static void Main()
    {
        CarPartFactory engineFactory = new HighPerformanceEngineFactory();
        ICarPart engine = engineFactory.CreateCarPart();
        Console.WriteLine(engine.GetDescription());

        // Output: Engine: High-performance engine

        CarPartFactory wheelFactory = new AlloyWheelFactory();
        ICarPart wheel = wheelFactory.CreateCarPart();
        Console.WriteLine(wheel.GetDescription());

        // Output: Wheel: Alloy wheels

        CarPartFactory interiorFactory = new LuxuryInteriorFactory();
        ICarPart interior = interiorFactory.CreateCarPart();
        Console.WriteLine(interior.GetDescription());

        // Output: Interior: Leather seats and advanced infotainment system
    }
}

Conclusion

In this example, the Factory Pattern allows us to create a flexible and extensible system for assembling cars. The separation of the creation logic into factory classes enables us to dynamically choose different combinations of car parts without modifying the client code.

The Factory Pattern, when applied judiciously, promotes code reusability, maintainability, and scalability, making it a valuable tool in the software designer's toolkit. As you embark on your software design journey, consider the Factory Pattern as a reliable ally in creating systems that can adapt to evolving requirements with grace and efficiency.

😊Please consider liking and following me for more articles and if you find this content helpful.👍