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 de conception comportemental qui définit le squelette d'un algorithme dans une classe de base, permettant aux sous-classes de redéfinir 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 des éléments individuels.

Ce patron utilise l'héritage et les 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
// Enregistrement à l'emplacement par défaut

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

Le patron Template Method est idéal lorsque plusieurs classes partagent la même structure d'algorithme 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 redéfinissables.

Défi

Facile

Construisons un système de génération de rapports en utilisant le modèle Template Method. Différents types de rapports (comme les rapports de ventes et les rapports d'inventaire) partagent la même structure globale - ils doivent tous collecter des données, les formater et afficher le résultat - mais chaque type de rapport gère ces étapes différemment.

Vous organiserez 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 le squelette de l'algorithme de génération de rapport via une méthode template 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 surcharge OutputReport() pour afficher Sending to warehouse manager
Program.cs : Rassemblez le tout en créant des instances de rapports et en les générant. La méthode template 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 rapport 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 comment les deux rapports suivent exactement la même structure d'algorithme (collecter, formater, afficher), mais l'implémentation de chaque étape est personnalisée. Le SalesReport utilise le comportement de sortie par défaut, tandis que InventoryReport le surcharge - démontrant ainsi comment le modèle Template Method vous permet de contrôler quelles étapes sont obligatoires à surcharger et lesquelles peuvent être personnalisées en option !

Aide-mémoire

Le patron de méthode (Template Method) définit le squelette d'un algorithme dans une classe de base, permettant aux sous-classes de redéfinir certaines étapes sans modifier la structure globale.

La classe de base contient une « méthode modèle » qui appelle une séquence d'étapes. Certaines étapes sont abstraites (doivent être implémentées par les sous-classes), tandis que d'autres peuvent être virtuelles (redéfinition facultative) :

public abstract class DataProcessor
{
    // Méthode modèle - 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");
}

Les sous-classes fournissent leurs propres implémentations tandis que la classe de base impose l'ordre des opérations :

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");
}

Utilisation :

DataProcessor csv = new CsvProcessor();
csv.Process();
// Reading CSV file
// Parsing CSV data
// Saving to default location

DataProcessor json = new JsonProcessor();
json.Process();
// Reading JSON file
// Parsing JSON data
// Saving to cloud

Le patron de méthode est idéal lorsque plusieurs classes partagent la même structure d'algorithme 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 aux méthodes surchargeables.

Essayez vous-même

using System;
using Reporting;

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