Menu
Article Design Patterns

Crafting Templates: A Comprehensive Guide to the Template Method Pattern in C#

Casper

Casper

• 3 min read

The Template Method Pattern is a behavioral design pattern that defines the skeleton of an algorithm in the superclass but lets subclasses override specific steps of the algorithm without changing its structure. This pattern allows a template algorithm to remain invariant while enabling variations in certain steps. In this article, we will explore the Template Method Pattern in-depth, examining its structure, advantages, and providing practical examples in C#.

Understanding the Template Method Pattern

The Template Method Pattern involves the following key components:

  1. AbstractClass: The class that declares the template method, which defines the steps of the algorithm. The template method typically contains calls to primitive operations and may include hooks.
  2. ConcreteClass: The class that implements the primitive operations and possibly overrides hooks defined in the abstract class. Instances of concrete classes are created to provide specific implementations of the algorithm.

Implementation in C#

Let's delve into a simple example of the Template Method Pattern in C#. Suppose we want to create a template for building a house with different construction steps. The steps include laying the foundation, building the walls, and adding a roof. The Template Method Pattern can be applied to define the construction process with customizable steps.

// Step 1: Define AbstractClass
public abstract class HouseTemplate
{
    // Template method defining the construction process
    public void BuildHouse()
    {
        LayFoundation();
        BuildWalls();
        AddRoof();
        Decorate();
    }

    // Primitive operation: Lay foundation
    protected abstract void LayFoundation();

    // Primitive operation: Build walls
    protected abstract void BuildWalls();

    // Primitive operation: Add roof
    protected abstract void AddRoof();

    // Hook: Decorate (optional, can be overridden by subclasses)
    protected virtual void Decorate()
    {
        Console.WriteLine("Adding interior decorations.");
    }
}

// Step 2: Implement ConcreteClass
public class WoodenHouse : HouseTemplate
{
    protected override void LayFoundation()
    {
        Console.WriteLine("Laying foundation with wooden planks.");
    }

    protected override void BuildWalls()
    {
        Console.WriteLine("Building walls with wooden panels.");
    }

    protected override void AddRoof()
    {
        Console.WriteLine("Adding a wooden roof.");
    }

    // Decorating method overridden to add wooden furniture
    protected override void Decorate()
    {
        base.Decorate();
        Console.WriteLine("Adding wooden furniture.");
    }
}

public class ConcreteHouse : HouseTemplate
{
    protected override void LayFoundation()
    {
        Console.WriteLine("Laying foundation with concrete.");
    }

    protected override void BuildWalls()
    {
        Console.WriteLine("Building walls with concrete blocks.");
    }

    protected override void AddRoof()
    {
        Console.WriteLine("Adding a concrete roof.");
    }
}

// Step 3: Client code
public class Client
{
    public void Run()
    {
        Console.WriteLine("Building a Wooden House:");
        HouseTemplate woodenHouse = new WoodenHouse();
        woodenHouse.BuildHouse();

        Console.WriteLine("\nBuilding a Concrete House:");
        HouseTemplate concreteHouse = new ConcreteHouse();
        concreteHouse.BuildHouse();
    }
}

In this example, HouseTemplate is the AbstractClass that declares the template method BuildHouse containing the construction steps. The template method calls primitive operations LayFoundation, BuildWalls, AddRoof, and the optional hook Decorate. WoodenHouse and ConcreteHouse are ConcreteClass implementations that provide specific details for each construction step.

Advantages of the Template Method Pattern

1. Code Reusability: The Template Method Pattern promotes code reuse by defining a common algorithm structure in the abstract class, allowing subclasses to reuse or override specific steps.

2. Consistent Algorithm Structure: The pattern ensures a consistent algorithm structure across multiple subclasses, making it easier to understand and maintain.

3. Flexibility: Subclasses can customize or extend specific steps of the algorithm without changing the overall structure.

4. Encapsulation: The template method encapsulates the algorithm in the abstract class, hiding the details of individual steps from clients.

Real-world Examples

1. Document Processing

In document processing applications, the Template Method Pattern can be applied to define a common document processing algorithm. Concrete classes representing different document types can then implement the template method with specific steps for parsing, analyzing, and formatting each document type.

2. Game Development

In game development, the pattern can be used to define a common game loop or character behavior. Concrete classes representing different levels or characters can override specific steps to provide unique behaviors while maintaining a consistent structure.

Conclusion

The Template Method Pattern is a versatile design pattern that facilitates the creation of algorithms with customizable steps. Through practical examples in C#, we have demonstrated how the Template Method Pattern can be applied to real-world scenarios, providing a blueprint for creating systems that involve common algorithm structures with variations in specific steps. Understanding and incorporating this pattern into your design practices can contribute to building modular, extensible, and maintainable software architectures, ensuring efficient algorithm development in your applications.

Share