I design pattern sono diverse soluzioni ai problemi di ingegneria del software. I software possono essere costruiti senza di loro, ma è molto più difficile.
Lascerò una serie di tre parti riguardanti i design pattern. In questo post, parlerò dei design pattern creativi.

I design pattern creativi sono design pattern che si occupano di meccanismi di creazione di oggetti, cercando di creare oggetti in un modo adatto alla situazione. La forma di base della creazione di oggetti potrebbe risultare in problemi di design o in un’aggiunta di complessità al design. I design pattern creativi risolvono questo problema controllando in qualche modo questa creazione di oggetti.
Fonte: wikipedia.org

Qui discuteremo i cinque design pattern creativi e come possiamo usarli in swift.

Questo tipo di design pattern è usato per istanziare un nuovo oggetto clonando un oggetto esistente chiamato prototipo.

Vedreste una funzione astratta di clonazione del protocollo Fruit implementata dalla classe Apple che effettivamente restituisce l’oggetto corrente stesso.

Eseguiamo il codice di cui sopra nel playground.

// Create a prototype
let prototype = Apple(count: 4)// Create a copy of existing object
let redApple: Apple = prototype.clone() as! Apple
redApple.count // 4// add own properties
redApple.set(price: "")
redApple.price // // Create a copy of existing object
let greenApple: Apple = prototype.clone() as! Apple
greenApple.count // 4// add own properties
greenApple.set(price: "")
greenApple.price // 

– Quando si clona un oggetto, tutte le proprietà di quell’oggetto vengono copiate in
un altro oggetto.
– Questo design pattern dovrebbe essere usato quando hai bisogno di creare un oggetto senza conoscere la gerarchia di quella classe

The Factory Method Pattern

È il design pattern più comunemente usato. Fondamentalmente, astrae semplicemente la creazione di un oggetto.

Crea una classe chiamata FruitFactory che restituisce il tipo di oggetto necessario.
Aggiungi un metodo statico che accetta un enum chiamato FruitType come parametro e restituisce l’oggetto necessario a runtime.

Ogni istanza restituita dalla factory sarebbe di tipo Interface(nel protocollo swift) che ogni classe candidata alla factory deve aver implementato.

Dopo aver eseguito il codice di cui sopra nel playground:

// get the object of class Orange from the FruitFactory class
let orange = FruitFactory.getFruit(forType: .orange)
orange?.getPrice() // "
orange?.getCount() // 2// get the object of class Grapes from the FruitFactory class
let grapes = FruitFactory.getFruit(forType: .grapes)
grapes?.getPrice() // ""
grapes?.getCount() // 1

– Il tipo dell’oggetto creato è determinato a runtime.
– Questo design pattern rende il codebase più flessibile per aggiungere o rimuovere nuovi tipi.

Questo ci introduce al concetto di programma a un’interfaccia, non un’implementazione.

Questo design pattern fornisce un’interfaccia per creare famiglie di oggetti correlati senza specificarne le classi concrete. Sono spesso implementati con il pattern Factory Method.

Abbiamo una fabbrica astratta chiamata Furniture Factory per creare diversi prodotti. La classe concreta Factory implementerà il protocollo Furniture Factory.

Eseguendo il codice precedente.

// create MyChair class object
let chair = Factory.createChair()
chair.count() // 4// create MyTable class object
let table = Factory.createTable()
table.count() // 1

– Rivela l’interfaccia, non la sua implementazione
– Abstract Factory è come un protocollo che useremo su una classe concreta per creare oggetti

Builder Pattern

Questo design pattern separa il processo di creazione di oggetti dal suo effettivo utilizzo.

Prima dichiariamo un protocollo astratto (o interfaccia) per creare il prodotto. In questo caso è il protocollo ShoeShop.
La classe Nike è un costruttore concreto per incapsulare il processo di creazione del prodotto.

Direttore crea l’oggetto utilizzando il protocollo costruttore. Director deve essere inizializzato con un oggetto conforme al protocollo ShoeShop.

Dopo aver eseguito il codice.

// create a nike object
let nike = Nike()// instantiate Director with nike object
let director = Director(shoeShop: nike)// encapsulated the process of producing the nike product
director.produce() // "Shoe produced"

– Usa il pattern Builder quando costruisce API pubbliche perché non rivela i dettagli dell’implementazione
– Nasconde la complessità. Fornisce una semplice API dietro un compito complesso.

Singleton Design Pattern

In swift definiamo classi Singleton usando la parola chiave static. Significa che l’oggetto sarà istanziato solo una volta. Le proprietà statiche sono inizializzate in modo pigro e non saranno istanziate fino alla chiamata.
C’è solo una copia di questo oggetto e viene usata dagli altri oggetti globalmente.

Possiamo vedere l’uso anche nei framework Apple:

// Shared url session
let urlSession = URLSession.shared// user defaults
let userDefaults = UserDefaults.standard

Dopo aver eseguito il codice

Vehicle.sharedInstance.getName() // "Car"

– Usiamo la parola chiave let per assicurarci che il valore di shredInstance non cambierà
– Non dimenticate di aggiungere l’inizializzatore privato in modo da impedire ad altre classi di chiamare i suoi inizializzatori di default

Ecco il link ai file del parco giochi.

La ragione principale per cui usiamo il Creational Design Pattern è di disaccoppiare la logica di creazione di un oggetto dal suo utilizzo. Aiuta a ridurre le complessità creando oggetti in modo controllato con soluzioni già menzionate e provate &.

Per leggere i design pattern comportamentali, ecco il link al blog.