Fornisci un esempio di implementazione del pattern di…

Il pattern "Costruttore" separa il processo di costruzione di un oggetto complesso dalla sua rappresentazione, in modo che lo stesso processo di costruzione possa creare diverse rappresentazioni. Si applica quando la creazione dell'oggetto richiede molteplici passaggi e configurazioni.

// L'astratto costruttore dichiara l'interfaccia per creare parti dell'oggetto.
public abstract class Builder
{
    public abstract void BuildPartA();
    public abstract void BuildPartB();
    public abstract Product GetResult();
}

// Il costruttore concreto implementa l'interfaccia Builder
// e costruisce e assembla le parti del prodotto.
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;
    }
}

// Il prodotto rappresenta un oggetto complesso che deve essere costruito.
public class Product
{
    private List<string> _parts = new List<string>();

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

    public void ListParts()
    {
        Console.WriteLine("Parti del prodotto: " + string.Join(", ", _parts));
    }
}

// Il direttore costruisce l'oggetto usando l'interfaccia Builder.
public class Director
{
    public void Construct(Builder builder)
    {
        builder.BuildPartA();
        builder.BuildPartB();
    }
}

// Esempio di utilizzo
public class Program
{
    public static void Main(string[] args)
    {
        Director director = new Director();
        ConcreteBuilder builder = new ConcreteBuilder(); // Creiamo un costruttore concreto

        director.Construct(builder); // Il direttore guida il processo di costruzione

        Product result = builder.GetResult(); // Otteniamo il prodotto finito
        result.ListParts(); // Mostriamo le parti del prodotto
    }
}

Componenti principali:

Builder: Interfaccia astratta per creare parti del prodotto finale.
ConcreteBuilder: Implementazione concreta di Builder, che costruisce e assembla le parti del prodotto.
Director: Classe che utilizza Builder per costruire passo dopo passo l'oggetto, senza conoscere il suo tipo concreto.
Product: Oggetto complesso che viene costruito.

Questo esempio dimostra come Director utilizza ConcreteBuilder per creare Product passo dopo passo, separando il processo di costruzione dalla sua rappresentazione.

Fornisci un esempio di implementazione del pattern di progettazione 'Costruttore' in C#.