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 des objets à une méthode ou une classe distincte. Au lieu d’utiliser directement new dans votre code, vous demandez à une factory de créer les objets pour vous. Cela centralise la logique de création et rend votre code plus flexible.

Imaginez un scénario où 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)
    {
        return type switch
        {
            "pdf" => new PdfDocument(),
            "word" => new WordDocument(),
            _ => 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 modèle Factory. Au lieu de créer directement différents types de notifications tout au long de votre code, vous centraliserez la logique de création dans une classe factory qui décide quelle notification créer en fonction d'un simple identifiant sous forme de chaîne.

Vous organiserez votre code sur trois fichiers :

Notification.cs : définissez une interface INotification dans l'espace de noms Notifications, avec une seule méthode Send(string message) qui retourne une chaîne. Créez ensuite trois classes qui implémentent cette interface :
- EmailNotification - retourne "Email: {message}"
- SmsNotification - retourne "SMS: {message}"
- PushNotification - retourne "Push: {message}"
NotificationFactory.cs : créez une classe NotificationFactory dans le même espace de noms, avec une méthode Create(string type) qui retourne l'INotification appropriée en fonction de la chaîne de type :
- "email" retourne un EmailNotification
- "sms" retourne un SmsNotification
- "push" retourne un PushNotification
Pour tout type non reconnu, retournez un EmailNotification par défaut.
Program.cs : rassemblez le tout en créant une instance de la factory et en l'utilisant pour créer des notifications à partir des entrées. La factory gère toutes les décisions 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 devrait être :

Push: Meeting in 5 minutes

Remarquez que votre code principal n'utilise jamais new EmailNotification() ou une construction similaire : il demande simplement à la factory ce dont il a besoin. Si vous ajoutez plus tard une classe SlackNotification, vous n'aurez besoin de mettre à jour que 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
    }
}