Le pattern Factory Method (ou Fabrique) est un modèle de conception de création qui définit une interface pour créer un objet, mais laisse les sous-classes décider de la classe à instancier. Ce mécanisme permet de déléguer la logique d'instanciation aux classes dérivées, favorisant ainsi le découplage entre le code client et les classes concrètes.

Structure Fondamentale

Dans une architecture basée sur ce pattern, nous distinguons deux hiérarchies parallèles : celle des produits (les objets à créer) et celle des créateurs (les usines).

1. Définition de l'Abstraction du Produit

Le produit définit l'interface des objets que la méthode de fabrication crée. Voici un exemple basé sur un système de traitement de documents :

public abstract class Document
{
    public abstract void Ouvrir();
    public abstract void Enregistrer();
    public abstract void Fermer();
}

2. Implémentation des Produits Concrets

Les produits concrets fournissent des implémentations spécifiques de l'interface produit.

public class DocumentPdf : Document
{
    public override void Ouvrir() => Console.WriteLine("Ouverture du PDF...");
    public override void Enregistrer() => Console.WriteLine("Enregistrement du PDF...");
    public override void Fermer() => Console.WriteLine("Fermeture du PDF...");
}

public class DocumentWord : Document
{
    public override void Ouvrir() => Console.WriteLine("Ouverture du document Word...");
    public override void Enregistrer() => Console.WriteLine("Enregistrement du document Word...");
    public override void Fermer() => Console.WriteLine("Fermeture du document Word...");
}

3. Le Créateur Abstrait

La classe créatrice déclare la méthode de fabrique qui retourne un objet de type Produit. Elle peut également fournir une implémentation par défaut.

public abstract class GestionnaireDocument
{
    // La Factory Method
    public abstract Document CreerDocument();

    public void TraiterDocument()
    {
        var doc = CreerDocument();
        doc.Ouvrir();
        doc.Enregistrer();
    }
}

4. Les Créateurs Concrets

Chaque créateur concret surcharge la méthode de fabrication pour retourner une instance spécifique du produit.

public class GestionnairePdf : GestionnaireDocument
{
    public override Document CreerDocument()
    {
        return new DocumentPdf();
    }
}

public class GestionnaireWord : GestionnaireDocument
{
    public override Document CreerDocument()
    {
        return new DocumentWord();
    }
}

Analyse de l'Indirection et du Découplage

L'utilisation du pattern Factory Method repose sur le principe d'inversion de dépendance. Au lieu que le code client instancie directemnet une classe concrète (comme new DocumentPdf()), il interagit avec une abstraction.

Considérons l'appel suivant :

GestionnaireDocument usine = new GestionnairePdf();
Document monDoc = usine.CreerDocument();
monDoc.Ouvrir();

L'avantage majeur réside dans la stabilité du code. Si le système doit évoluer pour supporter un nouveau format (par exemple, Excel), il suffit de créer une nouvelle classe DocumentExcel et une classe GestionnaireExcel. Le code existant qui manipule GestionnaireDocument n'a pas besoin d'être modifié.

Cette approche est particulièrement puissante lorqsu'elle est combinée avec la réflexion ou l'injection de dépendances, permettant de charger dynamiquement les types d'usines sans modifier le code source du client, rendant l'application extensible et conforme au principe Ouvert/Fermé (Open/Closed Principle).