Comment puis-je faire une référence de protocole faible en Swift "pur" (sans @objc) ?

Question

Les références faibles ne semblent pas fonctionner en Swift, sauf si un protocole est déclaré comme @objc, ce que je ne veux pas dans une application Swift pure :-)

Ce code donne lieu à une erreur de compilation ('weak' ne peut pas être appliqué au type non classe 'MyClassDelegate') :

class MyClass {
  weak var delegate: MyClassDelegate?
}

protocol MyClassDelegate {
}

Je dois préfixer le protocole avec @objc, puis cela fonctionne.

Question : Quelle est la méthode Swift "pure" pour réaliser un délégué faible ?

Answer 1

Mise à jour (Beta 5) : Xcode / Swift Beta 5 a changé la façon de déclarer l'exigence de classe pour un protocole. Au lieu d'utiliser @class_protocol vous devez maintenant déclarer le type du protocole comme étant class .

Avec la nouvelle syntaxe, l'exemple de code que j'ai posté avec la réponse originale serait le suivant :

protocol ProtocolNameDelegate: class {
    // Protocol stuff goes here
}

class SomeClass {
    weak var delegate: ProtocolNameDelegate?
}

L'idée est la même, mais la syntaxe est peut-être un peu plus propre.

Réponse originale (valable jusqu'à la bêta 5) :

Je pense que la manière correcte d'implémenter le modèle de délégué est de marquer votre protocole avec l'attribut class_protocol

Extrait du livre sur le langage de programmation Swift :

"classe_protocole Appliquez cet attribut à un protocole pour indiquer que le protocole ne peut être adopté que par des types de classe. Si vous appliquez l'attribut objc à un protocole, l'attribut class_protocol est implicitement appliqué à ce protocole ; il n'est pas nécessaire de marquer explicitement le protocole avec l'attribut class_protocol."

Si j'ai bien compris, en utilisant cet attribut, vous garantissez que ce protocole sera utilisé uniquement sur les classes et pas sur d'autres choses comme les enums ou les structs. De plus, vous pouvez voir que l'attribut objc implique l'attribut class_protocol, c'est pourquoi il fonctionne lorsque vous l'utilisez.

Pour mettre un exemple de code :

@class_protocol protocol ProtocolNameDelegate {
    // Protocol stuff goes here
}

class SomeClass {
    weak var delegate: ProtocolNameDelegate?
}

Answer 2

Réponse complémentaire

Je me suis toujours demandé si les délégués devaient être faibles ou non. Récemment, j'en ai appris davantage sur les délégués et sur le moment où il convient d'utiliser des références faibles. Permettez-moi donc d'ajouter quelques points supplémentaires pour les futurs utilisateurs.

• L'objectif de l'utilisation du weak mot-clé est d'éviter des cycles de référence solides (conserver les cycles). Les cycles de référence forte se produisent lorsque deux instances de classe ont des références fortes l'une à l'autre. Leur nombre de références ne tombe jamais à zéro et elles ne sont donc jamais désallouées.

• Vous devez seulement utiliser weak si le délégué est une classe. Les structs et les enums Swift sont des types de valeurs (leurs valeurs sont copiées lorsqu'une nouvelle instance est créée), et non des types de référence, ils ne font donc pas de fortes réductions. référence cycles.

• weak sont toujours facultatives (sinon vous auriez utilisé unowned ) et utilisez toujours var (pas let ) afin que l'option puisse être réglée sur nil lorsqu'il est désalloué.

• Une classe parent devrait naturellement avoir une référence forte à ses classes enfants et donc ne pas utiliser l'attribut weak mot-clé. Cependant, lorsqu'un enfant veut une référence à son parent, il doit en faire une référence faible en utilisant le mot-clé weak mot-clé.

• weak doit être utilisé lorsque vous voulez une référence à une classe que vous ne possédez pas, et pas seulement pour un enfant référençant son parent. Lorsque deux classes non hiérarchiques doivent se référer l'une à l'autre, choisissez-en une pour être faible. Le choix dépend de la situation. Voir les réponses à cette question pour en savoir plus.

• En règle générale, les délégués doivent être marqués en tant que weak parce que la plupart des délégués font référence à des classes qu'ils ne possèdent pas. C'est certainement vrai lorsqu'un enfant utilise un délégué pour communiquer avec un parent. L'utilisation d'une référence faible pour le délégué est ce que l'on appelle la documentation recommande. (Mais voir este aussi.)

• Les protocoles peuvent être utilisés à la fois pour types de référence (classes) et types de valeurs (structs, enums). Ainsi, dans le cas probable où vous devez rendre un délégué faible, vous devez en faire un protocole objet seulement. La façon de le faire est d'ajouter AnyObject à la liste d'héritage du protocole. (Dans le passé, vous faisiez cela en utilisant la fonction class mot-clé, mais AnyObject est préféré maintenant .)

  protocol MyClassDelegate: AnyObject {
      // ...
  }
  
  class SomeClass {
      weak var delegate: MyClassDelegate?
  }

Étude complémentaire

C'est la lecture des articles suivants qui m'a permis de mieux comprendre. Ils traitent également de questions connexes comme le unowned et les forts cycles de référence qui se produisent avec les fermetures.

• Documentation des délégués
• Documentation Swift : Comptage automatique des références
• "Weak, Strong, Unowned, Oh My !" (Faible, fort, inconnu) - Un guide des références dans Swift
• Strong, Weak, and Unowned - Faire le tri entre ARC et Swift

Related

• Comment créer des délégués en Swift
• iOS : comment créer des délégués faibles en Swift
• Délégation Swift - Quand utiliser le pointeur faible sur le délégué ?

Answer 3

AnyObject est la manière officielle d'utiliser une référence faible en Swift.

class MyClass {
    weak var delegate: MyClassDelegate?
}

protocol MyClassDelegate: AnyObject {
}

De Apple :

Pour éviter les cycles de référence forts, les délégués doivent être déclarés en tant que références faibles. Pour plus d'informations sur les références faibles, voir Cycles de référence forte entre instances de classe. Marquage du protocole comme étant réservé à une classe vous permettra ultérieurement de déclarer que le délégué doit utiliser une référence faible. Vous marquez un protocole comme étant de classe seulement en héritant de Tout objet comme indiqué dans la section Protocoles de classe unique.

https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-ID276

Answer 4

L'utilisation de @objc est la bonne façon de procéder même si vous n'interagissez pas avec Obj-C. Elle garantit que votre protocole est appliqué à une classe et non à un enum ou à un struct. Voir "Checking for Protocol Conformance" dans le manuel.

Answer 5

Le qualificatif faible ne s'applique qu'aux référence objets. À moins que vous n'ajoutiez le @objc , AnyObject ou class sur votre protocole, l'objet conforme au protocole peut ne pas être un objet de référence.

Ainsi, vous avez besoin d'un de ces qualificatifs (et de AnyObject est recommandé, car class est censé être déprécié).

Au fait, notez que l'ajout de @objc à vos classes et propriétés est parfois nécessaire, même dans les applications "purement Swift". Cela n'a rien à voir avec votre langage de développement. Il oblige le compilateur à construire votre code d'une manière compatible avec le runtime Objective-C, ce qui est nécessaire pour certaines interfaces du système d'exploitation (target/action et les chemins de clés de l'ancien style, par exemple).