Software Dev/14 - Template Method.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Template Method\n",
    "\n",
    "## General idea\n",
    "The Template Method pattern is a behavioral design pattern that defines the skeleton of an algorithm in a base class, allowing subclasses to provide specific implementations for certain steps of the algorithm. It promotes code reuse and encapsulates the common behavior in the base class while allowing subclasses to customize or extend specific parts of the algorithm.\n",
    "\n",
    "## Benefits\n",
    "The Template Method pattern provides several benefits:\n",
    "\n",
    "- Code Reusability: The Template Method pattern promotes code reuse by encapsulating common behavior in the abstract class. The common steps of the algorithm are implemented once in the abstract class and can be reused by all subclasses.\n",
    "\n",
    "- Encapsulation: The pattern encapsulates the algorithm's structure and allows subclasses to focus on implementing or customizing specific steps. Subclasses are not concerned with the overall algorithm flow, only with providing their specific behavior.\n",
    "\n",
    "- Flexibility and Extensibility: The Template Method pattern allows subclasses to customize or extend specific parts of the algorithm while maintaining the overall structure. By providing abstract methods, the pattern enables subclasses to inject their own behavior into the algorithm without modifying the core algorithm code.\n",
    "\n",
    "- Consistent Algorithm Structure: The pattern enforces a consistent structure for the algorithm across subclasses. The overall algorithm flow is defined in the base class, ensuring that all subclasses follow the same steps.\n",
    "\n",
    "- Simplified Maintenance: By encapsulating the common behavior in the abstract class, the Template Method pattern simplifies maintenance and updates. Changes to the common steps can be made in one place, affecting all subclasses that rely on the template method.\n",
    "\n",
    "- Separation of Concerns: The pattern separates the high-level algorithm from the specific implementations. This separation allows for better management of concerns and promotes a cleaner and more modular design.\n",
    "\n",
    "> The Template Method pattern is commonly used in scenarios where there is a common algorithm structure with variations in specific steps. It provides a framework for defining the overall algorithm flow while allowing subclasses to provide their specific implementations. This promotes code reuse, flexibility, and maintainability in software development.\n",
    "\n",
    "## How it works\n",
    "- The `AbstractClass` is an abstract class that defines the overall algorithm structure and declares the template method. This method consists of a series of steps, some of which are implemented directly in the abstract class, and others that are left abstract to be implemented by subclasses.\n",
    "\n",
    "- `ConcreteClass` extends the `AbstractClass` and provides concrete implementations for the abstract steps declared in the base class. These concrete implementations represent the varying behavior of the algorithm in different subclasses.\n",
    "\n",
    "- The template method in the `AbstractClass` coordinates the execution of the algorithm by calling the common steps implemented in the abstract class and the specific steps implemented in the subclasses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Example of implementation of template method pattern in C#\n",
    "\n",
    "// Abstract class defining the template method\n",
    "public abstract class AbstractClass\n",
    "{\n",
    "    public void TemplateMethod()\n",
    "    {\n",
    "        // Perform common steps\n",
    "        CommonStep1();\n",
    "        CommonStep2();\n",
    "\n",
    "        // Perform different steps\n",
    "        SpecificStep();\n",
    "\n",
    "        // Perform additional steps\n",
    "        AdditionalStep();\n",
    "    }\n",
    "\n",
    "    protected void CommonStep1()\n",
    "    {\n",
    "        Console.WriteLine(\"AbstractClass: Performing common step 1\");\n",
    "    }\n",
    "\n",
    "    protected void CommonStep2()\n",
    "    {\n",
    "        Console.WriteLine(\"AbstractClass: Performing common step 2\");\n",
    "    }\n",
    "\n",
    "    protected abstract void SpecificStep();\n",
    "\n",
    "    protected virtual void AdditionalStep()\n",
    "    {\n",
    "        Console.WriteLine(\"AbstractClass: Performing additional step\");\n",
    "    }\n",
    "}\n",
    "\n",
    "// Concrete class implementing specific steps\n",
    "public class ConcreteClass : AbstractClass\n",
    "{\n",
    "    protected override void SpecificStep()\n",
    "    {\n",
    "        Console.WriteLine(\"ConcreteClass: Performing specific step\");\n",
    "    }\n",
    "\n",
    "    protected override void AdditionalStep()\n",
    "    {\n",
    "        Console.WriteLine(\"ConcreteClass: Performing additional step override\");\n",
    "    }\n",
    "}\n",
    "\n",
    "// Client\n",
    "public class Client\n",
    "{\n",
    "    public void Code()\n",
    "    {\n",
    "        // Create concrete class instance\n",
    "        AbstractClass abstractClass = new ConcreteClass();\n",
    "\n",
    "        // Call the template method\n",
    "        abstractClass.TemplateMethod();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## In this example:\n",
    "\n",
    "- The `AbstractClass` represents the abstract class defining the template method. It provides a template method `TemplateMethod()` that defines the overall structure of the algorithm, calling common and specific steps. The common steps are implemented in the abstract class itself, while the specific step is defined as an abstract method that must be implemented by the concrete classes.\n",
    "\n",
    "- The `ConcreteClass` extends the `AbstractClass` and implements the specific step. It provides its own implementation of the abstract method `SpecificStep()`, which represents the varying behavior of the algorithm.\n",
    "\n",
    "- The `Client` class demonstrates how the Template Method pattern is used. It creates an instance of the concrete class (`ConcreteClass`) and calls the template method `TemplateMethod()`.\n",
    "\n",
    "> By utilizing the Template Method pattern, you can define the overall structure of an algorithm in an abstract class, while allowing the specific steps to be implemented by the concrete classes. This promotes code reuse and encapsulates the common behavior in the abstract class, allowing for variations in the specific steps. It provides a framework for defining algorithms with a fixed structure but customizable behavior."
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}