Pattern Factory

Fa parte della sezione Programmazione orientata agli oggetti del percorso C# di Coddy. Lezione 53 di 70.

Il pattern Factory è un pattern creazionale che delega la creazione degli oggetti a un metodo o a una classe separati. Invece di usare direttamente new nel codice, chiedi a una factory di creare gli oggetti per te. Questo centralizza la logica di creazione e rende il codice più flessibile.

Considera uno scenario in cui devi creare diversi tipi di documenti. Senza una factory, il tuo codice diventa strettamente accoppiato a classi specifiche:

// Senza Factory - logica di creazione sparsa
IDocument doc;
if (type == "pdf")
    doc = new PdfDocument();
else if (type == "word")
    doc = new WordDocument();

Una factory racchiude questo processo decisionale in un unico posto:

public interface IDocument
{
    void Open();
}
public class PdfDocument : IDocument
{
    public void Open() => Console.WriteLine("Opening PDF");
}
public class WordDocument : IDocument
{
    public void Open() => Console.WriteLine("Opening Word");
}
public class DocumentFactory
{
    public IDocument Create(string type)
    {
        switch (type)
        {
            case "pdf":
                return new PdfDocument();
            case "word":
                return new WordDocument();
            default:
                throw new ArgumentException("Unknown type");
        }
    }
}

Ora il codice client richiede semplicemente ciò di cui ha bisogno senza conoscere le classi concrete:

var factory = new DocumentFactory();
IDocument doc = factory.Create("pdf");
doc.Open();  // Apertura del PDF

Il pattern Factory è ideale quando devi aggiungere nuovi tipi in un secondo momento. Per aggiungere un SpreadsheetDocument è necessario modificare solo la factory, non tutti i punti in cui vengono creati i documenti. Questa separazione rende il tuo codice più facile da mantenere e testare.

Sfida

Facile

Costruiamo un sistema di notifiche usando il pattern Factory. Invece di creare direttamente diversi tipi di notifiche in tutto il codice, centralizzerai la logica di creazione in una classe factory che decide quale notifica creare in base a un semplice identificatore stringa.

Organizzerai il codice in tre file:

Notification.cs: Definisci un'interfaccia INotification nello spazio dei nomi Notifications con un unico metodo Send(string message) che restituisce una stringa. Poi crea tre classi che implementano questa interfaccia:
- EmailNotification - restituisce "Email: {message}"
- SmsNotification - restituisce "SMS: {message}"
- PushNotification - restituisce "Push: {message}"
NotificationFactory.cs: Crea una classe NotificationFactory nello stesso spazio dei nomi, con un metodo Create(string type) che restituisce la INotification appropriata in base alla stringa type:
- "email" restituisce un'EmailNotification
- "sms" restituisce una SmsNotification
- "push" restituisce una PushNotification
Per qualsiasi type non riconosciuto, restituisci un'EmailNotification come valore predefinito.
Program.cs: Metti insieme tutti gli elementi creando un'istanza della factory e usandola per creare notifiche in base all'input. La factory gestisce tutte le decisioni su quale classe concreta istanziare.

Riceverai due input:

Il tipo di notifica (ad es., sms)
Il messaggio da inviare (ad es., Your order has shipped)

Usa la factory per creare il tipo di notifica appropriato, poi chiama il suo metodo Send con il messaggio e stampa il risultato.

Ad esempio, se gli input sono push e Meeting in 5 minutes, l'output dovrebbe essere:

Push: Meeting in 5 minutes

Nota che il codice principale non usa mai new EmailNotification() o simili: chiede semplicemente alla factory ciò di cui ha bisogno. Se in seguito aggiungi una SlackNotification, dovrai aggiornare solo la factory, non tutti i punti in cui vengono create le notifiche!

Provalo tu

using System;
using Notifications;

class Program
{
    public static void Main(string[] args)
    {
        // Leggi l'input
        string type = Console.ReadLine();
        string message = Console.ReadLine();

        // TODO: Crea un'istanza di NotificationFactory

        // TODO: Usa la factory per creare la notifica appropriata

        // TODO: Chiama il metodo Send e stampa il risultato
    }
}