Mastering the Template Design Pattern in C#

Structure of the Template Method Pattern

The Template Method Design Pattern defines the skeleton of an algorithm in a base class and lets subclasses override specific steps without changing the overall structure. The pattern typically involves the following components :

• Abstract Class : Contains the template method defining the algorithm's structure and abstract methods representing steps to be implemented by subclasses.
• Template Method : Template Method: Defines the sequence of steps, calling both implemented and abstract methods to execute the algorithm.
• Concrete Classes : Implement the abstract methods, providing specific behaviors for the algorithm's steps.

public abstract class TemplateBase
{
    public sealed void TemplateMethod()
    {
        Step1();
        Step2(); // Hook
        Step3();
    }

    protected abstract void Step1();
    protected virtual void Step2() { } // Optional hook
    protected abstract void Step3();
}

Implementing the Template Method Pattern in C#

public abstract class DataProcessor
{
    // Template method defining the algorithm's structure
    public void Process()
    {
        ReadData();
        ProcessData();
        WriteData();
        Log(); // Optional hook
    }

    protected abstract void ReadData();
    protected abstract void ProcessData();
    protected abstract void WriteData();

    // Hook method with default implementation
    protected virtual void Log()
    {
        Console.WriteLine("Default logging: Processing completed.");
    }
}

public class CsvDataProcessor : DataProcessor
{
    protected override void ReadData()
    {
        Console.WriteLine("Reading data from CSV file...");
    }
    protected override void ProcessData()
    {
        Console.WriteLine("Processing CSV data...");
    }
    protected override void WriteData()
    {
        Console.WriteLine("Writing processed CSV data...");
    }
}

public class XmlDataProcessor : DataProcessor
{
    protected override void ReadData()
    {
        Console.WriteLine("Reading data from XML file...");
    }
    protected override void ProcessData()
    {
        Console.WriteLine("Processing XML data...");
    }
    protected override void WriteData()
    {
        Console.WriteLine("Writing processed XML data...");
    }
    protected override void Log()
    {
        Console.WriteLine("Custom log: XML processing done.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        DataProcessor csvProcessor = new CsvDataProcessor();
        csvProcessor.Process();

        Console.WriteLine("-----------");

        DataProcessor xmlProcessor = new XmlDataProcessor();
        xmlProcessor.Process();
    }
}

When to Use the Template Method Pattern

• Consistent Algorithm Structure: You have an algorithm with a fixed sequence of steps, but some steps require customization.
• Code Reusability: You aim to avoid code duplication by centralizing common behaviors in a base class.
• Centralizing non-functional concerns (logging, error handling, etc.) : Template methods can handle cross-cutting concerns in the base class, keeping subclasses clean and focused.
• Maintaining consistent behavior across subclasses : Prevents subclasses from accidentally omitting essential steps or changing the execution order.
• Providing controlled customization with hook methods : Allows optional customization points with sensible defaults, reducing the need for boilerplate in subclasses.
• Separating high-level policy from low-level details : Base class defines what needs to be done, while subclasses define how to do it.
• Building hierarchical or rule-driven logic flows : Great for workflows, decision trees, or rules engines where logic progresses through defined stages.

When Not to Use

• Dynamic Behavior Changes: The algorithm's steps need to change dynamically at runtime. Consider the Strategy Pattern in such cases.
• High flexibility or composition preference: If your design favors composition over inheritance or requires high flexibility, other patterns like the Strategy or State patterns might be more appropriate.
• Simple Algorithms : For straightforward algorithms that don't require variation, implementing the Template Method pattern can introduce unnecessary layers and complexity.

Advantages

• Promotes Code Reuse: Centralizes common logic, reducing duplication.
• Ensures Consistency: Maintains a consistent algorithm structure across different implementations.
• Enhances Maintainability: Simplifies updates and maintenance by localizing changes to specific subclasses.
• Creating testable and mockable systems : Each step of the algorithm can be overridden, allowing fine-grained unit testing or mocking of behavior.
• Applying behavioral consistency across domains : When multiple business domains share a conceptual flow (e.g., order processing, payment workflows), the Template Pattern enforces uniform behavior.
• (“Don’t call us, we’ll call you”)—subclasses don’t dictate control flow, they just fill in the blanks defined by the base class.

Disadvantages

• Inflexibility: The fixed algorithm structure may not accommodate all use cases.
• Complex Hierarchies: Overuse can lead to deep inheritance hierarchies, complicating the codebase.

Real-World Applications

• Data Processing Frameworks: Reading, processing, and writing data with varying formats.
• Web Frameworks: Defining request handling pipelines with customizable steps.
• Testing Frameworks: Setting up test cases with standardized setup and teardown procedures.

FAQs