Le design pattern Builder est un modèle de conception créatif qui sépare la construction d'un objet complexe de sa représentation, permettant ainsi de créer différentes représentations de cet objet en utilisant le même processus de construction. Cela rend la création d'objets complexes plus flexible et maintenable.
En C#, le Builder est souvent mis en œuvre en utilisant une interface ou une classe abstraite pour définir le contrat de construction, et des classes concrètes (ou des implémentations) pour construire différentes représentations de l'objet.
Voici un exemple simple d'implémentation du design pattern Builder en C# :
```csharp
using System;
// Produit complexe
public class Pizza
{
public string Dough { get; set; }
public string Sauce { get; set; }
public string Topping { get; set; }
public void Display()
{
Console.WriteLine($"Pizza with {Dough} dough, {Sauce} sauce, and {Topping} topping.");
}
}
// Interface du Builder
public interface IPizzaBuilder
{
void BuildDough();
void BuildSauce();
void BuildTopping();
Pizza GetPizza();
}
// Constructeur concret pour une pizza spécifique
public class MargheritaPizzaBuilder : IPizzaBuilder
{
private Pizza pizza = new Pizza();
public void BuildDough()
{
pizza.Dough = "Thin Crust";
}
public void BuildSauce()
{
pizza.Sauce = "Tomato Sauce";
}
public void BuildTopping()
{
pizza.Topping = "Mozzarella Cheese";
}
public Pizza GetPizza()
{
return pizza;
}
}
// Directeur qui utilise le constructeur pour créer le produit
public class PizzaDirector
{
private IPizzaBuilder pizzaBuilder;
public PizzaDirector(IPizzaBuilder builder)
{
pizzaBuilder = builder;
}
public void MakePizza()
{
pizzaBuilder.BuildDough();
pizzaBuilder.BuildSauce();
pizzaBuilder.BuildTopping();
}
}
class Program
{
static void Main()
{
// Utilisation du Builder pour créer une pizza Margherita
IPizzaBuilder builder = new MargheritaPizzaBuilder();
PizzaDirector director = new PizzaDirector(builder);
director.MakePizza();
Pizza margheritaPizza = builder.GetPizza();
margheritaPizza.Display();
}
}
```
Dans cet exemple, `Pizza` est le produit complexe que nous voulons construire. L'interface `IPizzaBuilder` définit le contrat de construction, et `MargheritaPizzaBuilder` est une implémentation concrète de ce contrat, construisant une pizza margherita spécifique. Le `PizzaDirector` utilise le constructeur pour guider le processus de construction. Ce modèle permet de créer différents types de pizzas en fournissant simplement d'autres implémentations de `IPizzaBuilder`.
Aucun commentaire:
Enregistrer un commentaire