Les patrons de conception sont des solutions différentes à des problèmes de génie logiciel. Les logiciels peuvent être construits sans eux mais c’est beaucoup plus difficile.
Je vais publier une série en trois parties concernant le design pattern. Dans ce post, je vais discuter des patrons de conception créatifs.

Les patrons de conception créatifs sont des patrons de conception qui traitent des mécanismes de création d’objets, en essayant de créer des objets d’une manière adaptée à la situation. La forme de base de la création d’objets pourrait entraîner des problèmes de conception ou une complexité supplémentaire à la conception. Les patrons de conception créatifs résolvent ce problème en contrôlant d’une manière ou d’une autre cette création d’objets.
Source : wikipedia.org

C’est ici que nous allons discuter des cinq patrons de conception créatifs et de la manière dont nous pouvons les utiliser dans swift.

Ce type de patron de conception est utilisé pour instancier un nouvel objet en clonant un objet existant appelé prototype.

Vous verriez une fonction clone abstraite du protocole Fruit implémentée par la classe Apple qui renvoie en fait l’objet courant lui-même.

Exécutons le code ci-dessus dans le 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 // 

– Lorsque vous clonez un objet, toutes les propriétés de cet objet sont copiées sur
un autre objet.
– Ce patron de conception doit être utilisé lorsque vous devez créer un objet sans connaître la hiérarchie de cette classe

Le patron de méthode d’usine

C’est le patron de conception le plus couramment utilisé. Fondamentalement, il ne fait qu’abstraire la création d’un objet.

Créer une classe appelée FruitFactory qui renvoie le type de l’objet nécessaire.
Ajouter une méthode statique qui accepte une enum appelée FruitType comme paramètre et renvoie l’objet nécessaire au moment de l’exécution.

Toute instance renvoyée par la factory serait de type Interface(dans le protocole swift) que toute classe candidate à la factory doit avoir implémentée.

Après avoir exécuté le code ci-dessus dans le 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

– Le type de l’objet créé est déterminé au moment de l’exécution.
– Ce design pattern rend la base de code plus flexible pour ajouter ou supprimer de nouveaux types.

Cela nous introduit au concept de programme à une interface, pas à une implémentation.

Ce design pattern fournit une interface pour créer des familles d’objets liés sans spécifier leurs classes concrètes. Ils sont souvent mis en œuvre avec le pattern Factory Method.

Nous avons une usine abstraite appelée Furniture Factory pour créer différents produits. La classe d’usine concrète Factory implémentera le protocole Furniture Factory.

En exécutant le code ci-dessus.

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

– Révèle l’interface, pas leur implémentation
– L’usine abstraite est comme un protocole que nous utiliserons sur une classe concrète pour créer des objets

Patron constructeur

Ce patron de conception sépare le processus de création d’objets de son utilisation réelle.

D’abord nous déclarons un protocole abstrait(ou interface) pour créer le produit. Dans ce cas, c’est le protocole ShoeShop.
La classe Nike est un constructeur concret pour encapsuler le processus de création du produit.

Directeur crée un objet en utilisant le protocole du constructeur. Director doit être initialisé avec un objet conforme au protocole ShoeShop.

Après avoir exécuté le code.

// 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"

– Utiliser le pattern Builder lors de la construction d’API publiques car il ne révèle pas les détails de l’implémentation
– Cache la complexité. Il fournit une API simple derrière une tâche complexe.

Singleton Design Pattern

Dans swift nous définissons des classes Singleton en utilisant le mot clé static. Cela signifie que l’objet va être instancié une seule fois. Les propriétés statiques sont initialisées paresseusement et ne seront pas instanciées avant d’être appelées.
Il n’y a qu’une seule copie de cet objet et elle est utilisée par les autres objets globalement.

Nous pouvons voir l’utilisation dans les frameworks Apple également:

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

Après avoir exécuté le code

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

– Nous utilisons le mot-clé let pour nous assurer que la valeur de shredInstance ne changera pas
– N’oubliez pas d’ajouter l’initialisateur privé afin d’empêcher les autres classes d’appeler ses initialisateurs par défaut

Voici le lien vers les fichiers du playground.

La raison principale pour laquelle nous utilisons le Patron de Conception Créationnel est de découpler la logique de création d’un objet de son utilisation. Il permet de réduire les complexités en créant des objets de manière contrôlée avec des solutions éprouvées &déjà mentionnées.

Pour lire sur les patrons de conception comportementaux, voici le lien vers le blog.