Le patron de conception Constructeur (Builder Pattern) est une approche de création d'objets qui sépare la logique de construction d'un objet complexe de sa représentation. Il est particulièrement utile lorsque le processus de création d'un objet est long, implique de nombreuses étapes, ou nécessite la configuraton de multiples paramètres. Ce patron permet de simplifier la création d'objets en proposant une méthode pas à pas, où chaque étape se concentre sur la construction d'une partie spécifique de l'objet.

Structure du Patron

Le patron Constructeur se compose généralement des éléments suivants :

• Produit (Product) : L'objet complexe qui est en cours de construction. Il est souvent composé de plusieurs parties ou attributs.
• Constructeur Abstrait (Builder) : Une interface ou une classe abstraite qui définit les méthodes pour construire les différentes parties du Produit.
• Constructeur Concret (Concrete Builder) : Une implémentation du Constructeur Abstrait. Chaque Constructeur Concret est responsable de la construction et de l'assemblage des parties du Produit selon une représentation spécifique.
• Directeur (Director) : Il orchestre le processus de construction en utilisant une instance de Construcetur Concret. Le Directeur ne connaît pas les détails de la construction, il délègue les appels aux méthodes du Constructeur pour construire le Produit étape par étape.

Fonctionnement

1. Le client instancie un Directeur et lui associe un Constructeur Concret.
2. Le Directeur utilise les méthodes du Constructeur Concret pour construire les différentes parties du Produit dans un ordre défini.
3. Le Constructeur Concret met en œuvre les instructions de construction, assemblant les composants du Produit.
4. Une fois la construction terminée, le Directeur récupère le Produit final via le Constructeur Concret.
5. Le client obtient le Produit fini sans avoir à gérer la complexité du processus de construction.

Exemple de Code (C#)

Produit : Personnage

Représente l'objet complexe que nous allons construire, un personnage de jeu vidéo avec des caractéristiques faciales et vestimentaires.

namespace VideoGameCharacterBuilder;

public struct Character
{
   public string HairStyle { get; set; }
   public string EyeColor { get; set; }
   public string NoseShape { get; set; }
   public string EarType { get; set; }
   public string MouthExpression { get; set; }

   public string Outfit { get; set; }
   public string Trousers { get; set; }
   public string Footwear { get; set; }

   public override string ToString()
   {
       return $"[Hair:{HairStyle},Eyes:{EyeColor},Nose:{NoseShape},Ears:{EarType},Mouth:{MouthExpression},Outfit:{Outfit},Trousers:{Trousers},Footwear:{Footwear}]";
   }
}
 

Interface du Constructeur : ICharacterBuilder

Définit les étapes communes pour construire un personnage.

namespace VideoGameCharacterBuilder;

public interface ICharacterBuilder
{
   void DefineFacialFeatures();
   void SetAttire();
   Character GetConstructedCharacter();
}
 

Constructeurs Concrets : MaleCharacterBuilder et FemaleCharacterBuilder

Implémentent l'interface pour construire des personnages masculins et féminins spécifiques.

namespace VideoGameCharacterBuilder;

// Constructeur pour personnage masculin
public class MaleCharacterBuilder : ICharacterBuilder
{
   private Character _character = new Character();

   public void DefineFacialFeatures()
   {
       _character.HairStyle = "Masculine court";
       _character.EyeColor = "Bleu";
       _character.NoseShape = "Carré";
       _character.EarType = "Standard";
       _character.MouthExpression = "Neutre";
   }

   public void SetAttire()
   {
       _character.Outfit = "Chemise simple";
       _character.Trousers = "Jean";
       _character.Footwear = "Bottes";
   }

   public Character GetConstructedCharacter()
   {
       return _character;
   }
}

// Constructeur pour personnage féminin
public class FemaleCharacterBuilder : ICharacterBuilder
{
   private Character _character = new Character();

   public void DefineFacialFeatures()
   {
       _character.HairStyle = "Féminin long";
       _character.EyeColor = "Vert";
       _character.NoseShape = "Fin";
       _character.EarType = "Discret";
       _character.MouthExpression = "Souriant";
   }

   public void SetAttire()
   {
       _character.Outfit = "Robe d'été";
       _character.Trousers = "Aucun";
       _character.Footwear = "Sandales";
   }

   public Character GetConstructedCharacter()
   {
       return _character;
   }
}
 

Directeur : CharacterBuildDirector

Orchestre le processus de construction en utilisant un constructeur donné.

namespace VideoGameCharacterBuilder;

public class CharacterBuildDirector
{
   private readonly ICharacterBuilder _builder;

   public CharacterBuildDirector(ICharacterBuilder builder)
   {
       _builder = builder;
   }

   public Character CreateCharacter()
   {
       _builder.DefineFacialFeatures();
       _builder.SetAttire();
       return _builder.GetConstructedCharacter();
   }
}
 

Code d'Utilisation : Main Program

Démontre comment utiliser le patron Constructeur pour créer différents personnages.

// ************* Test du Patron Constructeur **************
using VideoGameCharacterBuilder;

var maleCharBuilder = new MaleCharacterBuilder();
var femaleCharBuilder = new FemaleCharacterBuilder();

// Créer un personnage masculin
var maleDirector = new CharacterBuildDirector(maleCharBuilder);
var maleCharacter = maleDirector.CreateCharacter();

// Créer un personnage féminin
var femaleDirector = new CharacterBuildDirector(femaleCharBuilder);
var femaleCharacter = femaleDirector.CreateCharacter();

// Afficher les personnages créés
Console.WriteLine("Personnage Masculin: " + maleCharacter);
Console.WriteLine("Personnage Féminin: " + femaleCharacter);
 

Explication du Code

Cet exemple illustre la création de personnages par défaut pour un jeu vidéo, en différenciant les aspects masculins et féminins. Le patron Constructeur est idéal ici car la définition des traits du visage et des vêtements implique de nombreux attributs. Les constructeurs dédiés (MaleCharacterBuilder, FemaleCharacterBuilder) gèrent les spécificités de chaque genre. Le Directeur (CharacterBuildDirector) centralise la séquence de construction, assurant que toutes les étapes sont exécutées dans le bon ordre pour produire un personnage complet.