Patron Fabrique

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

Le pattern Factory est un pattern de création qui délègue la création d’objets à une méthode ou une classe distincte. Au lieu d’utiliser directement new dans votre code, vous demandez à une factory de créer des objets pour vous. Cela centralise la logique de création et rend votre code plus flexible.

Imaginez un scénario dans lequel vous devez créer différents types de documents. Sans fabrique, votre code devient fortement couplé à des classes spécifiques :

// Sans Factory - logique de création dispersée
IDocument doc;
if (type == "pdf")
    doc = new PdfDocument();
else if (type == "word")
    doc = new WordDocument();

Une fabrique encapsule cette prise de décision en un seul endroit :

public interface IDocument
{
    void Open();
}
public class PdfDocument : IDocument
{
    public void Open() => Console.WriteLine("Opening PDF");
}
public class WordDocument : IDocument
{
    public void Open() => Console.WriteLine("Opening Word");
}
public class DocumentFactory
{
    public IDocument Create(string type)
    {
        switch (type)
        {
            case "pdf":
                return new PdfDocument();
            case "word":
                return new WordDocument();
            default:
                throw new ArgumentException("Unknown type");
        }
    }
}

Désormais, le code client demande simplement ce dont il a besoin sans connaître les classes concrètes :

var factory = new DocumentFactory();
IDocument doc = factory.Create("pdf");
doc.Open();  // Ouverture du PDF

Le modèle Factory est particulièrement utile lorsque vous devez ajouter de nouveaux types ultérieurement. L’ajout d’un SpreadsheetDocument ne nécessite des modifications que dans la fabrique, et non partout où les documents sont créés. Cette séparation rend votre base de code plus facile à maintenir et à tester.

Défi

Facile

Construisons un système de notifications en utilisant le pattern Factory. Au lieu de créer directement différents types de notifications partout dans votre code, vous centraliserez la logique de création dans une classe factory qui décidera quelle notification créer en fonction d’un simple identifiant sous forme de chaîne.

Vous organiserez votre code dans trois fichiers :

Notification.cs : définissez une interface INotification dans l’espace de noms Notifications, avec une seule méthode Send(string message) qui renvoie une chaîne. Créez ensuite trois classes qui implémentent cette interface :
- EmailNotification - renvoie "Email: {message}"
- SmsNotification - renvoie "SMS: {message}"
- PushNotification - renvoie "Push: {message}"
NotificationFactory.cs : créez une classe NotificationFactory dans le même espace de noms, avec une méthode Create(string type) qui renvoie l’INotification appropriée en fonction de la chaîne de type :
- "email" renvoie un EmailNotification
- "sms" renvoie un SmsNotification
- "push" renvoie un PushNotification
Pour tout type non reconnu, renvoyez un EmailNotification par défaut.
Program.cs : rassemblez tous les éléments en créant une instance de la factory et en l’utilisant pour créer des notifications à partir des entrées. La factory prend en charge toute la logique de décision concernant la classe concrète à instancier.

Vous recevrez deux entrées :

Le type de notification (par exemple, sms)
Le message à envoyer (par exemple, Your order has shipped)

Utilisez votre factory pour créer le type de notification approprié, puis appelez sa méthode Send avec le message et affichez le résultat.

Par exemple, si les entrées sont push et Meeting in 5 minutes, la sortie doit être :

Push: Meeting in 5 minutes

Remarquez que votre code principal n’utilise jamais new EmailNotification() ni un équivalent : il demande simplement à la factory ce dont il a besoin. Si vous ajoutez ultérieurement une classe SlackNotification, vous devrez uniquement mettre à jour la factory, et non chaque endroit qui crée des notifications !

Essayez vous-même

using System;
using Notifications;

class Program
{
    public static void Main(string[] args)
    {
        // Lire l'entrée
        string type = Console.ReadLine();
        string message = Console.ReadLine();

        // TODO: Créer une instance de NotificationFactory

        // TODO: Utiliser la factory pour créer la notification appropriée

        // TODO: Appeler la méthode Send et afficher le résultat
    }
}