Donnez un exemple de mise en œuvre du patron de…

Le motif "Constructeur" sépare le processus de construction d'un objet complexe de sa représentation, de sorte que le même processus de construction puisse créer différentes représentations. Il s'applique lorsque la création de l'objet nécessite plusieurs étapes et configurations.

// L'abstrait constructeur déclare l'interface pour créer des parties de l'objet.
public abstract class Builder
{
    public abstract void BuildPartA();
    public abstract void BuildPartB();
    public abstract Product GetResult();
}

// Le constructeur concret implémente l'interface Builder
// et construit et assemble les parties du produit.
public class ConcreteBuilder : Builder
{
    private Product _product = new Product();

    public override void BuildPartA()
    {
        _product.Add("PartA");
    }

    public override void BuildPartB()
    {
        _product.Add("PartB");
    }

    public override Product GetResult()
    {
        return _product;
    }
}

// Le produit représente un objet complexe qui doit être construit.
public class Product
{
    private List<string> _parts = new List<string>();

    public void Add(string part)
    {
        _parts.Add(part);
    }

    public void ListParts()
    {
        Console.WriteLine("Parts du produit: " + string.Join(", ", _parts));
    }
}

// Le directeur construit l'objet en utilisant l'interface Builder.
public class Director
{
    public void Construct(Builder builder)
    {
        builder.BuildPartA();
        builder.BuildPartB();
    }
}

// Exemple d'utilisation
public class Program
{
    public static void Main(string[] args)
    {
        Director director = new Director();
        ConcreteBuilder builder = new ConcreteBuilder(); // Création d'un constructeur concret

        director.Construct(builder); // Le directeur guide le processus de construction

        Product result = builder.GetResult(); // Obtention du produit fini
        result.ListParts(); // Affichage des parties du produit
    }
}

Composants principaux:

Builder: Interface abstraite pour créer des parties du produit final.
ConcreteBuilder: Implémentation concrète de Builder, qui construit et assemble les parties du produit.
Director: Classe qui utilise Builder pour construire étape par étape l'objet, sans connaître son type concret.
Product: Objet complexe qui est construit.

Cet exemple montre comment Director utilise ConcreteBuilder pour créer Product étape par étape, séparant le processus de construction de sa représentation.

Donnez un exemple de mise en œuvre du patron de conception 'Constructeur' en C#.