Gestionnaire d'achèvement VS détenant une référence: le plus approprié pour ce scénario dans Swift?

Question

J'ai le scénario suivant: un objet A crée un objet B qui devrait effectuer certaines opérations en fonction du choix de l'utilisateur. A est délégué de B. A ne contient pas de référence au choix effectué par l'utilisateur (représenté par un autre objet C), mais il le sait dans la méthode où il crée B, et il doit savoir quel est le choix lorsque l'objet B termine sa tâche et avertit de cela en appelant la méthode de protocole correspondante implémentée par A.

La première solution que je pense pour ce scénario est d'avoir une référence dans A pour le choix C, et l'accès dans la mise en œuvre de la méthode de protocole qui B appels quand il se termine. Mais peut-être qu'il serait préférable et plus "swifty" de gérer un tel choix en passant un gestionnaire de complétion, et ainsi éviter de conserver une référence dans A jusqu'à B finit.

Que pensez-vous de cette seconde solution (passer une fermeture en tant que gestionnaire d'achèvement à B)? Serait-il plus approprié que la première solution (contenant une référence dans A)?

Dans un tel cas, comment dois-je implémenter cette solution? Est-ce que B doit avoir une référence pour que la fermeture soit appelée comme gestionnaire d'achèvement?

EDIT: Quelques informations supplémentaires de mon scénario:

• A n'a pas exactement une propriété B, il le pousse dans un contrôleur de navigation.
• A n'a pas toujours besoin de savoir sur C quand B finitions, cela dépend de la tâche demandée à B
• A doit seulement savoir sur C une fois B (en fonction de la tâche effectuée par B, comme dit précédemment) a terminé pour mettre à jour certaines données.
• A doit seulement savoir (en fonction de la tâche effectuée par B, comme dit précédemment) une seule C à la fois

Answer 1

En bref, dans la hiérarchie de la propriété A possède B, les deux classes utilisent C et que vous voulez pour savoir si C doit être détenue par A ou B.

Vous avez 3 options de base:

1. deux A et B propre C.

Cela signifie que A arrêts C dans une propriété, il passe à B lors de l'initialisation et B enregistre également C à une propriété.

2. A possède C.

Cela signifie que A arrêts C dans une propriété et ne passe pas à B du tout. B le demande en utilisant une méthode déléguée quand il en a besoin (A sert de source de données pour B).

3. B possède C.

Cela signifie A passe C directement à B, B enregistre dans une propriété avec un getter public et quand A a besoin C, il le lit de B.

(Notez que votre idée est une variante de la troisième option).

Notez qu'aucune des trois options n'a quelque chose à voir avec swiftiness, c'est purement un choix d'architecture et il n'y a pas de "meilleure" solution. Si vous voulez décider, vous devez considérer les états de votre application, par exemple:

1. Si C exister dans A même après B est détruite? Si oui, n'utilisez pas la 3ème option.

2. Est-ce que A gère plusieurs fois B ou C? Ensuite, n'utilisez pas la deuxième option.

3. Est-ce que C est modifiable ou non? Est-ce une valeur ou un type de classe? S'il s'agit d'un type de valeur, vous ne pouvez pas utiliser la première option.

Dans la plupart des cas toutes les 3 options ci-dessus sera fine et le choix sera une décision personnelle qui n'affectera pas la qualité de votre code si vous le gardez cohérente dans votre application.

EDIT:

Il me semble que la 3ème option est vraiment la solution pour votre manière la plus adéquate situation. Cependant, comme je l'ai déjà dit, il n'y a pas une «meilleure» solution.