Introduction aux patrons de conception

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

Les patrons de conception (design patterns) sont des solutions éprouvées à des problèmes courants que les développeurs rencontrent de manière répétée lors de la création de logiciels. Plutôt que de réinventer la roue à chaque fois, ces patrons nous offrent un vocabulaire commun et des approches testées pour structurer le code.

Considérez les patrons de conception comme des plans. Ils ne vous donnent pas de code exact à copier, mais ils décrivent comment organiser les classes et les objets pour résoudre des défis spécifiques. Quand quelqu'un mentionne « utilisez le patron Factory ici », les développeurs expérimentés comprennent immédiatement la structure générale proposée.

Les patrons de conception se répartissent en trois catégories principales :

Catégorie	Objectif	Exemples
Création	Comment les objets sont créés	Singleton, Factory
Structure	Comment les objets sont composés	Adapter, Decorator
Comportement	Comment les objets communiquent	Observer, Strategy

Les modèles que nous allons explorer s'appuient directement sur les concepts de la POO que vous avez déjà appris : les interfaces, l'héritage, le polymorphisme et la composition. Chaque modèle exploite ces fondamentaux de manières spécifiques pour atteindre la flexibilité, la maintenabilité ou la réutilisabilité.

Dans les prochaines leçons, vous implémenterez plusieurs patterns essentiels en commençant par Singleton, Factory, Observer et Strategy. Comprendre ces patterns vous aidera à reconnaître des solutions courantes dans les bases de code existantes et à prendre de meilleures décisions architecturales dans vos propres projets.

Défi

Facile

Construisons un système simple de catalogue de patrons qui organise les informations sur les patrons de conception à travers plusieurs fichiers. Cela vous aidera à comprendre comment les patrons sont catégorisés tout en pratiquant une bonne organisation du code.

Vous allez créer trois fichiers pour séparer les différentes responsabilités :

Pattern.cs : Définissez une classe Pattern dans l'espace de noms Patterns qui représente un seul patron de conception. Chaque patron doit avoir un Name, une Category (Creational, Structural, ou Behavioral), et une Description. Incluez une méthode GetSummary() qui retourne une chaîne formatée : [{Category}] {Name}: {Description}
PatternCatalog.cs : Créez une classe PatternCatalog dans l'espace de noms Patterns qui gère une collection de patrons. Votre catalogue doit pouvoir ajouter des patrons et posséder une méthode GetPatternsByCategory(string category) qui retourne une liste de tous les patrons correspondant à cette catégorie. Incluez également une méthode GetAllSummaries() qui retourne une liste de chaînes de résumé pour tous les patrons du catalogue.
Program.cs : Rassemblez le tout en créant un catalogue et en le remplissant de patrons basés sur l'entrée. Ensuite, affichez les patrons filtrés par catégorie.

Vous recevrez les entrées suivantes :

Le nombre de patrons à ajouter
Pour chaque patron : trois lignes contenant le nom, la catégorie et la description
Une catégorie pour filtrer

Après avoir ajouté tous les patrons à votre catalogue, affichez les résumés des patrons qui correspondent à la catégorie de filtre, un par ligne. Si aucun patron ne correspond, affichez No patterns found.

Par exemple, si les entrées sont :

3
Singleton
Creational
Ensures only one instance exists
Observer
Behavioral
Notifies dependents of state changes
Factory
Creational
Creates objects without specifying exact class
Creational

La sortie devrait être :

[Creational] Singleton: Ensures only one instance exists
[Creational] Factory: Creates objects without specifying exact class

Ce défi démontre comment l'organisation de classes liées dans des fichiers séparés maintient votre base de code propre et facile à maintenir - un principe qui devient encore plus important à mesure que vous implémentez de réels patrons de conception dans les leçons à venir !

Aide-mémoire

Les patrons de conception (design patterns) sont des solutions éprouvées à des problèmes courants dans le développement de logiciels. Ils fournissent des modèles pour organiser les classes et les objets plutôt que du code exact à copier.

Les patrons de conception se répartissent en trois catégories principales :

Catégorie	Objectif	Exemples
Création	Comment les objets sont créés	Singleton, Factory
Structure	Comment les objets sont composés	Adapter, Decorator
Comportement	Comment les objets communiquent	Observer, Strategy

Les patrons de conception s'appuient sur les concepts de la POO tels que les interfaces, l'héritage, le polymorphisme et la composition pour atteindre la flexibilité, la maintenabilité et la réutilisabilité.

Essayez vous-même

using System;
using System.Collections.Generic;
using Patterns;

class Program
{
    public static void Main(string[] args)
    {
        // Lire le nombre de motifs
        int n = Convert.ToInt32(Console.ReadLine());
        
        // Créer un nouveau PatternCatalog
        PatternCatalog catalog = new PatternCatalog();
        
        // TODO: Lire les détails de chaque motif (name, category, description)
        // et les ajouter au catalogue
        for (int i = 0; i < n; i++)
        {
            string name = Console.ReadLine();
            string category = Console.ReadLine();
            string description = Console.ReadLine();
            
            // TODO: Créer un Pattern et l'ajouter au catalogue
        }
        
        // Lire la catégorie pour filtrer
        string filterCategory = Console.ReadLine();
        
        // TODO: Obtenir les motifs par la catégorie de filtre
        // et imprimer leurs résumés
        // Si aucun motif ne correspond, imprimer "No patterns found"
    }
}