Patrón Template Method

Parte de la sección Programación Orientada a Objetos del Journey de C# de Coddy. Lección 59 de 70.

El patrón Template Method es un patrón de comportamiento que define el esqueleto de un algoritmo en una clase base, permitiendo que las subclases redefinan pasos específicos sin cambiar la estructura general. La clase base controla el flujo de trabajo, mientras que las clases derivadas personalizan piezas individuales.

Este patrón utiliza herencia y métodos abstractos. La clase base contiene un «método plantilla» que llama a una secuencia de pasos, algunos de los cuales son abstractos y deben ser implementados por las subclases:

public abstract class DataProcessor
{
    // Método plantilla - define la estructura del algoritmo
    public void Process()
    {
        ReadData();
        ProcessData();
        SaveData();
    }
    
    protected abstract void ReadData();
    protected abstract void ProcessData();
    protected virtual void SaveData() => Console.WriteLine("Saving to default location");
}

public class CsvProcessor : DataProcessor
{
    protected override void ReadData() => Console.WriteLine("Reading CSV file");
    protected override void ProcessData() => Console.WriteLine("Parsing CSV data");
}

public class JsonProcessor : DataProcessor
{
    protected override void ReadData() => Console.WriteLine("Reading JSON file");
    protected override void ProcessData() => Console.WriteLine("Parsing JSON data");
    protected override void SaveData() => Console.WriteLine("Saving to cloud");
}

Cada subclase proporciona su propia implementación, mientras que la clase base impone el orden de las operaciones:

DataProcessor csv = new CsvProcessor();
csv.Process();
// Leyendo archivo CSV
// Analizando datos CSV
// Saving to default location

DataProcessor json = new JsonProcessor();
json.Process();
// Leyendo archivo JSON
// Analizando datos JSON
// Guardando en la nube

El patrón Template Method es ideal cuando varias clases comparten la misma estructura de algoritmo, pero difieren en pasos específicos. Promueve la reutilización del código al colocar la lógica común en la clase base, a la vez que permite flexibilidad mediante métodos que se pueden sobrescribir.

Desafío

Fácil

Construyamos un sistema de generación de informes usando el patrón Template Method. Los distintos tipos de informes (como los informes de ventas y los informes de inventario) comparten la misma estructura general: todos necesitan recopilar datos, darles formato y generar el resultado, pero cada tipo de informe gestiona estos pasos de manera diferente.

Organizarás tu código en tres archivos:

ReportGenerator.cs: Crea una clase abstracta ReportGenerator en el espacio de nombres Reporting. Esta clase base define el esqueleto del algoritmo de generación de informes mediante un método plantilla llamado Generate(). El método debe llamar a tres pasos en orden: GatherData(), FormatReport() y OutputReport(). Haz que GatherData() y FormatReport() sean abstractos (cada tipo de informe los implementará de manera diferente), mientras que OutputReport() debe ser un método virtual con una implementación predeterminada que imprima Sending to default printer.
ConcreteReports.cs: Crea dos clases concretas de informes en el mismo espacio de nombres que hereden de ReportGenerator:
- SalesReport: implementa GatherData() para imprimir Collecting sales data from database y FormatReport() para imprimir Formatting as sales summary
- InventoryReport: implementa GatherData() para imprimir Scanning warehouse inventory, FormatReport() para imprimir Formatting as inventory list y sobrescribe OutputReport() para imprimir Sending to warehouse manager
Program.cs: Une todo creando instancias de informes y generándolos. El método plantilla garantiza que cada informe siga el mismo proceso de tres pasos, pero el comportamiento específico de cada paso varía según el tipo de informe.

Recibirás una entrada:

El tipo de informe: sales o inventory

Crea el generador de informes apropiado según la entrada y llama a su método Generate().

Por ejemplo, si la entrada es sales, la salida debe ser:

Collecting sales data from database
Formatting as sales summary
Sending to default printer

Si la entrada es inventory, la salida debe ser:

Scanning warehouse inventory
Formatting as inventory list
Sending to warehouse manager

Observa cómo ambos informes siguen exactamente la misma estructura de algoritmo (recopilar, dar formato y generar), pero la implementación de cada paso está personalizada. SalesReport utiliza el comportamiento de salida predeterminado, mientras que InventoryReport lo sobrescribe. Esto demuestra cómo el patrón Template Method te permite controlar qué pasos son obligatorios de sobrescribir y cuáles se pueden personalizar opcionalmente.

Pruébalo tú mismo

using System;
using Reporting;

class Program
{
    public static void Main(string[] args)
    {
        string reportType = Console.ReadLine();
        
        // TODO: Crea el generador de informes apropiado basándote en reportType
        // Si reportType es "sales", crea un SalesReport
        // Si reportType es "inventory", crea un InventoryReport
        // Luego llama al método Generate() en el informe
        
    }
}