Topic 18518 min readStructured Tutorial

Factory Pattern in C#

Quick Answer

The Factory Pattern in C# is a creational design pattern that provides an interface for creating objects in a superclass but allows subclasses to alter the type of objects that will be created. It promotes loose coupling and enhances code maintainability by encapsulating object creation logic.

Learning Objectives

Explain the purpose of Factory Pattern in a practical learning context.
Identify the main ideas, terms, and decisions involved in Factory Pattern.
Apply Factory Pattern in a simple real-world scenario or practice task.

Introduction

Design patterns are proven solutions to common software design problems. The Factory Pattern is one of the fundamental creational patterns in C#.

It helps manage object creation by abstracting the instantiation process, making your code more flexible and easier to maintain.

Encapsulate object creation to promote loose coupling.

What is the Factory Pattern?

The Factory Pattern defines an interface for creating an object but lets subclasses decide which class to instantiate.

This pattern delegates the responsibility of object instantiation to subclasses, promoting flexibility and scalability.

Separates object creation from usage.
Supports open/closed principle by allowing new types without modifying existing code.
Improves code maintainability and readability.

When to Use the Factory Pattern

Use the Factory Pattern when your code needs to create objects without specifying the exact class of the object to be created.

It is especially useful when the system needs to be independent of how its objects are created, composed, and represented.

When a class can't anticipate the class of objects it must create.
When subclasses should specify the objects to be created.
To centralize object creation logic.

Implementing the Factory Pattern in C#

The Factory Pattern typically involves a factory class with a method that returns different types of objects based on input parameters or logic.

Below is a simple example demonstrating the pattern.

Example: Shape Factory

Consider a scenario where you want to create different shapes like Circle and Rectangle without exposing the instantiation logic to the client.

Practical Example

This example defines an interface IShape and two implementations: Circle and Rectangle. The ShapeFactory class has a method GetShape that returns an instance of the requested shape. The client code uses the factory to get shape objects without knowing their concrete classes.

Examples

C# Factory Pattern Example - Shape Factory

public interface IShape {
    void Draw();
}

public class Circle : IShape {
    public void Draw() {
        Console.WriteLine("Drawing a Circle");
    }
}

public class Rectangle : IShape {
    public void Draw() {
        Console.WriteLine("Drawing a Rectangle");
    }
}

public class ShapeFactory {
    public IShape GetShape(string shapeType) {
        if (shapeType == null) return null;
        if (shapeType.Equals("CIRCLE", StringComparison.OrdinalIgnoreCase)) {
            return new Circle();
        } else if (shapeType.Equals("RECTANGLE", StringComparison.OrdinalIgnoreCase)) {
            return new Rectangle();
        }
        return null;
    }
}

// Usage
class Program {
    static void Main() {
        ShapeFactory factory = new ShapeFactory();
        IShape shape1 = factory.GetShape("CIRCLE");
        shape1.Draw();
        IShape shape2 = factory.GetShape("RECTANGLE");
        shape2.Draw();
    }
}

Best Practices

Use interfaces or abstract classes for the products created by the factory.
Keep the factory method focused on object creation only.
Avoid complex logic inside the factory method; delegate if necessary.
Use the Factory Pattern to adhere to the Open/Closed Principle.
Document the factory's behavior clearly for maintainability.

Common Mistakes

Creating too many factory classes unnecessarily.
Putting business logic inside the factory instead of just object creation.
Returning null without handling it properly in client code.
Not using interfaces or abstractions for created objects.
Overcomplicating the factory method with unrelated responsibilities.

Hands-on Exercise

Implement a Vehicle Factory

Create a factory class that can instantiate different types of vehicles like Car, Bike, and Truck implementing a common interface IVehicle with a method Drive().

Expected output: Console output showing the Drive() method being called on different vehicle instances.

Hint: Define an IVehicle interface and concrete classes for each vehicle type. Implement a factory method that returns the correct vehicle based on input.

Interview Questions

What is the Factory Pattern and why is it used?

Interview

The Factory Pattern is a creational design pattern that abstracts the process of object creation. It is used to create objects without specifying the exact class of the object to be created, promoting loose coupling and flexibility.

How does the Factory Pattern promote the Open/Closed Principle?

Interview

By encapsulating object creation in a factory, new product types can be added by extending the factory without modifying existing client code, thus adhering to the Open/Closed Principle.

What is the difference between Factory Method and Abstract Factory patterns?

Interview

The Factory Method pattern uses inheritance to decide which class to instantiate, while the Abstract Factory pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes.