Sélectionner une page


le Modèle de constructeur est un Design pattern Conçu pour fournir une solution flexible à divers problèmes de création d’objets dans Programmation orientée objet. L’intention du modèle de conception du constructeur est séparé la construction d’un objet complexe à partir de sa représentation. C’est l’un des Modèle de conception de groupe de quatre.

Aperçu[edit]

Le modèle de conception du constructeur est l’un des Exemple de conception du GoF[1] Celles-ci décrivent comment les problèmes de conception récurrents peuvent être résolus dans un logiciel orienté objet.

Le modèle de conception du constructeur résout des problèmes tels que:[2]

  • Comment une classe (même processus de construction) peut-elle créer différentes représentations d’un objet complexe?
  • Comment simplifier une classe qui implique la création d’un objet complexe?

Créer et assembler les parties d’un objet complexe directement dans une classe est inflexible. Il oblige la classe à créer une représentation spécifique de l’objet complexe et rend impossible de changer ultérieurement la représentation indépendamment de la classe (sans avoir à la changer).

Le modèle de conception du constructeur décrit comment résoudre ces problèmes:

  • Rassemblez la création et l’assemblage des parties d’un objet complexe dans un objet séparé Builder Objet.
  • Une classe délègue la création d’objets à un Builder Objet plutôt que de créer directement les objets.

Une classe (même processus de construction) peut déléguer à différentes Builder Objets pour créer différentes représentations d’un objet complexe.

définition[edit]

Le modèle de conception du générateur est destiné à séparer la construction d’un objet complexe de sa représentation. De cette manière, le même processus de conception peut produire différentes représentations.[1]

avantages[edit]

Les avantages du modèle Builder incluent:[3]

  • Permet de faire varier l’apparence interne d’un produit.
  • Encapsule le code pour la construction et la représentation.
  • Fournit un contrôle sur les étapes du processus de construction.

désavantage[edit]

Les inconvénients du modèle de constructeur comprennent:[3]

  • Un ConcreteBuilder distinct doit être créé pour chaque type de produit.
  • Les classes de constructeur doivent être modifiables.
  • Peut gêner / rendre difficile l’injection de toxicomanie.

structure[edit]

Classe UML et diagramme de séquence[edit]

Un exemple de classe UML et de diagramme de séquence pour le modèle de conception du générateur.[4]

Au dessus UML Diagramme de classe, les Director La classe ne les crée pas et ne les assemble pas ProductA1 et ProductB1 Objets directement. Au lieu de cela, le Director fait référence à Builder Interface de création (création et assemblage) des parties d’un objet complexe, permettant ainsi la Director quelles que soient les classes spécifiques instanciées (quelle représentation est créée). le Builder1 La classe implémente le Builder Interface en créant et en assemblant le ProductA1 et ProductB1 Objets.

le UML Diagramme de séquençage affiche les interactions d’exécution: Le Director Appels d’objets buildPartA() sur le Builder1 Objet qui crée et assemble ce ProductA1 Objet. Après cela, le Director Appels buildPartB() au Builder1qui crée et assemble le ProductB1 Objet.

Diagramme de classe[edit]

Structure du constructeur
constructeur
Interface abstraite pour créer des objets (produit).
ConcreteBuilder
Fournit la mise en œuvre pour les constructeurs. C’est un Objet qui peut construire d’autres objets. Construit et assemble des pièces pour créer les objets.

Exemples[edit]

C #[edit]

/// <summary>
/// Represents a product created by the builder
/// </summary>
public class Bicycle
{
    public string Make { get; set; }
    public string Model { get; set; }
    public int Height { get; set; }
    public string Colour { get; set; }

    public Bicycle(string make, string model, string colour, int height)
    {
        Make = make;
        Model = model;
        Colour = colour;
        Height = height;
    }
}

/// <summary>
/// The builder abstraction
/// </summary>
public interface IBicycleBuilder
{
    string Colour { get; set; }
    int Height { get; set; }

    Bicycle GetResult();
}

/// <summary>
/// Concrete builder implementation
/// </summary>
public class GTBuilder : IBicycleBuilder
{
    public string Colour { get; set; }
    public int Height { get; set; }

    public Bicycle GetResult()
    {
        return Height == 29 ? new Bicycle("GT", "Avalanche", Colour, Height) : null;        
    }
}

/// <summary>
/// The director
/// </summary>
public class MountainBikeBuildDirector
{
    private IBicycleBuilder _builder;
    public MountainBikeBuildDirector(IBicycleBuilder builder) 
    {
        _builder = builder;
    }

    public void Construct()
    {
        _builder.Colour = "Red";
        _builder.Height = 29;
    }
}

public class Client
{
    public void DoSomethingWithBicycles()
    {
        var builder = new GTBuilder();
        var director = new MountainBikeBuildDirector(builder);

        director.Construct();
        Bicycle myMountainBike = builder.GetResult();
    }
}

Dans l’exemple ci-dessus, le directeur assemble une instance de vélo et délègue la construction à un objet constructeur distinct qui a été transmis au directeur par le client.

Voir également[edit]

Les références[edit]

Liens externes[edit]




Source link

Recent Posts