Template Method Pattern

The Template Method Pattern is a behavioral design pattern that defines the skeleton of an algorithm in a base method, allowing certain steps to be implemented or customized by subclasses. This approach promotes code reuse, enforces a consistent process, and enables flexibility by letting subclasses override specific steps without altering the overall algorithm structure.

Real-World Analogy

Think of making tea or coffee. The general process is the same: boil water, brew the beverage, pour into a cup, and optionally add condiments. The steps are consistent, but the implementation of "brew beverage" differs.

Pattern Structure

                      classDiagram
                        class AbstractClass {
                          +TemplateMethod()
                          +BaseOperation1()
                          +BaseOperation2()
                          #RequiredOperation1()
                          #RequiredOperation2()
                          +Hook()
                        }
                        class ConcreteClass {
                          +RequiredOperation1()
                          +RequiredOperation2()
                        }
                        AbstractClass <|-- ConcreteClass
                      

💻 Code Example

The following example demonstrates the Template Method pattern using a Beverage preparation scenario.

                      abstract class CaffeineBeverage {
                          public void PrepareRecipe() {
                              BoilWater();
                              Brew();
                              PourInCup();
                              AddCondiments();
                          }
                      
                          void BoilWater() => Console.WriteLine("Boiling water");
                          void PourInCup() => Console.WriteLine("Pouring into cup");
                      
                          public abstract void Brew();
                          public abstract void AddCondiments();
                      }
                      
                      class Tea : CaffeineBeverage {
                          public override void Brew() => Console.WriteLine("Steeping the tea");
                          public override void AddCondiments() => Console.WriteLine("Adding lemon");
                      }
                      

                      from abc import ABC, abstractmethod
                      
                      class CaffeineBeverage(ABC):
                          def prepare_recipe(self):
                              self.boil_water()
                              self.brew()
                              self.pour_in_cup()
                              self.add_condiments()
                      
                          def boil_water(self):
                              print("Boiling water")
                      
                          def pour_in_cup(self):
                              print("Pouring into cup")
                      
                          @abstractmethod
                          def brew(self): pass
                      
                          @abstractmethod
                          def add_condiments(self): pass
                      
                      class Tea(CaffeineBeverage):
                          def brew(self):
                              print("Steeping the tea")
                          def add_condiments(self):
                              print("Adding lemon")
                      

Key Points

When to Use

• When multiple classes share the same algorithm structure.
  Example:

  
                        // Base class defines the template
                        abstract class ReportGenerator {
                            public void Generate() {
                                    FetchData();
                                    FormatData();
                                    PrintReport();
                            }
                            protected abstract void FetchData();
                            protected abstract void FormatData();
                            protected virtual void PrintReport() => Console.WriteLine("Printing report...");
                        }
                        
                        // Subclass customizes steps
                        class SalesReport : ReportGenerator {
                            protected override void FetchData() => Console.WriteLine("Fetching sales data");
                            protected override void FormatData() => Console.WriteLine("Formatting sales data");
                        }
                                

• To prevent code duplication by reusing base logic.
  Example:

  
                        class DataProcessor(ABC):
                            def process(self):
                                    self.load()
                                    self.transform()
                                    self.save()
                            @abstractmethod
                            def load(self): pass
                            @abstractmethod
                            def transform(self): pass
                            def save(self):
                                    print("Saving data")
                        
                        class CsvProcessor(DataProcessor):
                            def load(self): print("Loading CSV")
                            def transform(self): print("Transforming CSV")
                                

• To enforce an invariant algorithm structure across implementations.
  Example:

  
                        abstract class Game {
                            public void Play() {
                                    Start();
                                    while (!IsOver()) {
                                            TakeTurn();
                                    }
                                    End();
                            }
                            protected abstract void Start();
                            protected abstract bool IsOver();
                            protected abstract void TakeTurn();
                            protected abstract void End();
                        }
                                

Advantages and Disadvantages

🧠 Quiz