Patron Méthode Template

Fait partie de la section Programmation Orientée Objet du Journey C# de Coddy. Leçon 59 sur 70.

Le patron Template Method est un patron comportemental qui définit le squelette d’un algorithme dans une classe de base, permettant aux sous-classes de remplacer certaines étapes sans modifier la structure globale. La classe de base contrôle le flux de travail, tandis que les classes dérivées personnalisent certains éléments.

Ce modèle utilise l’héritage et des méthodes abstraites. La classe de base contient une « méthode modèle » qui appelle une séquence d’étapes, dont certaines sont abstraites et doivent être implémentées par les sous-classes :

public abstract class DataProcessor
{
    // Méthode template - définit la structure de l'algorithme
    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");
}

Chaque sous-classe fournit sa propre implémentation, tandis que la classe de base impose l’ordre des opérations :

DataProcessor csv = new CsvProcessor();
csv.Process();
// Lecture du fichier CSV
// Analyse des données CSV
// Saving to default location

DataProcessor json = new JsonProcessor();
json.Process();
// Lecture du fichier JSON
// Analyse des données JSON
// Sauvegarde dans le cloud

Le patron Template Method est idéal lorsque plusieurs classes partagent la même structure algorithmique, mais diffèrent dans certaines étapes spécifiques. Il favorise la réutilisation du code en plaçant la logique commune dans la classe de base, tout en permettant une certaine flexibilité grâce à des méthodes pouvant être redéfinies.

Défi

Facile

Construisons un système de génération de rapports à l'aide du patron Template Method. Différents types de rapports (comme les rapports de ventes et les rapports d'inventaire) partagent la même structure générale : ils doivent tous collecter les données, les formater et produire le résultat, mais chaque type de rapport gère ces étapes différemment.

Vous allez organiser votre code sur trois fichiers :

ReportGenerator.cs : créez une classe abstraite ReportGenerator dans l'espace de noms Reporting. Cette classe de base définit la structure de l'algorithme de génération de rapports grâce à une méthode modèle appelée Generate(). La méthode doit appeler trois étapes dans l'ordre : GatherData(), FormatReport() et OutputReport(). Rendez GatherData() et FormatReport() abstraites (chaque type de rapport les implémentera différemment), tandis que OutputReport() doit être une méthode virtuelle avec une implémentation par défaut qui affiche Sending to default printer.
ConcreteReports.cs : créez deux classes de rapports concrètes dans le même espace de noms, qui héritent de ReportGenerator :
- SalesReport : implémente GatherData() pour afficher Collecting sales data from database et FormatReport() pour afficher Formatting as sales summary
- InventoryReport : implémente GatherData() pour afficher Scanning warehouse inventory, FormatReport() pour afficher Formatting as inventory list, et redéfinit OutputReport() pour afficher Sending to warehouse manager
Program.cs : rassemblez tous les éléments en créant des instances de rapports et en les générant. La méthode modèle garantit que chaque rapport suit le même processus en trois étapes, mais le comportement spécifique de chaque étape varie en fonction du type de rapport.

Vous recevrez une entrée :

Le type de rapport : sales ou inventory

Créez le générateur de rapports approprié en fonction de l'entrée et appelez sa méthode Generate().

Par exemple, si l'entrée est sales, la sortie doit être :

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

Si l'entrée est inventory, la sortie doit être :

Scanning warehouse inventory
Formatting as inventory list
Sending to warehouse manager

Remarquez que les deux rapports suivent exactement la même structure d'algorithme (collecte, formatage, sortie), mais que l'implémentation de chaque étape est personnalisée. SalesReport utilise le comportement de sortie par défaut, tandis que InventoryReport le redéfinit — cela montre comment le patron Template Method vous permet de contrôler quelles étapes doivent obligatoirement être redéfinies et lesquelles peuvent être personnalisées de manière facultative !

Essayez vous-même

using System;
using Reporting;

class Program
{
    public static void Main(string[] args)
    {
        string reportType = Console.ReadLine();
        
        // TODO: Créez le générateur de rapport approprié en fonction de reportType
        // Si reportType est "sales", créez un SalesReport
        // Si reportType est "inventory", créez un InventoryReport
        // Ensuite, appelez la méthode Generate() sur le rapport
        
    }
}