Comment puis-je gérer la dépréciation de l'inférence @objc avec #selector () dans Swift 4?

J'essaie de convertir le code source de mon projet de Swift 3 à Swift 4. Un avertissement que Xcode me donne concerne mes sélecteurs.

Par exemple, j'ajoute une cible à un bouton en utilisant un sélecteur régulier comme celui-ci:

button.addTarget(self, action: #selector(self.myAction), for: .touchUpInside)

Voici l'avertissement qu'il affiche:

L'argument de '#selector' fait référence à la méthode d'instance 'myAction ()' dans 'ViewController' qui dépend de l'inférence d'attribut '@objc' obsolète dans Swift 4

Ajoutez '@objc' pour exposer cette méthode d'instance à Objective-C

Maintenant, appuyer Fixsur le message d'erreur fait ceci à ma fonction:

// before
func myAction() { /* ... */ }

// after
@objc func myAction() { /* ... */ }

Je ne veux pas vraiment renommer toutes mes fonctions pour inclure la @objcmarque et je suppose que ce n'est pas nécessaire.

Comment réécrire le sélecteur pour gérer la dépréciation?

Question connexe:

• L'utilisation de l'inférence Swift 3 @objc en mode Swift 4 est obsolète?

Le correctif est correct - il n'y a rien dans le sélecteur que vous pouvez changer pour que la méthode à laquelle il se réfère soit exposée à Objective-C.

La raison de cet avertissement en premier lieu est le résultat du SE-0160 . Avant Swift 4, internalou les membres compatibles Objective-C ou supérieurs des NSObjectclasses héritières étaient déduits comme étant @objcet donc exposés à Objective-C, leur permettant ainsi d'être appelés à l'aide de sélecteurs (car le runtime Obj-C est nécessaire pour rechercher la méthode implémentation pour un sélecteur donné).

Cependant dans Swift 4, ce n'est plus le cas. Seules les déclarations très spécifiques sont désormais supposées être @objc, par exemple, des substitutions de @objcméthodes, des implémentations d' @objcexigences de protocole et des déclarations avec des attributs qui impliquent @objc, tels que @IBOutlet.

La motivation derrière cela, comme détaillé dans la proposition liée ci-dessus , est tout d'abord d'éviter que les surcharges de méthodes lors de l' NSObjecthéritage de classes ne se heurtent en raison de sélecteurs identiques. Deuxièmement, cela aide à réduire la taille binaire en n'ayant pas à générer des thunks pour les membres qui n'ont pas besoin d'être exposés à Obj-C, et troisièmement, améliore la vitesse de liaison dynamique.

Si vous souhaitez exposer un membre à Obj-C, vous devez le marquer comme @objc, par exemple:

class ViewController: UIViewController {

    @IBOutlet weak var button: UIButton!

    override func viewDidLoad() {
        super.viewDidLoad()
        button.addTarget(self, action: #selector(foo), for: .touchUpInside)
    }

    @objc func foo() {
       // ... 
    }
}

(le programme de migration doit le faire automatiquement pour vous avec des sélecteurs lors de l'exécution avec l'option «minimiser l'inférence» sélectionnée)

Pour exposer un groupe de membres à Obj-C, vous pouvez utiliser un @objc extension:

@objc extension ViewController {

    // both exposed to Obj-C
    func foo() {}
    func bar() {}
}

Cela exposera tous les membres qui y sont définis à Obj-C, et donnera une erreur sur tous les membres qui ne peuvent pas être exposés à Obj-C (sauf s'ils sont explicitement marqués comme @nonobjc).

Si vous avez une classe où vous avez besoin que tous les membres compatibles Obj-C soient exposés à Obj-C, vous pouvez marquer la classe comme @objcMembers:

@objcMembers
class ViewController: UIViewController {
   // ...
}

Maintenant, tous les membres qui peuvent être déduits le @objcseront. Cependant, je ne conseillerais pas de faire cela à moins que vous n'ayez vraiment besoin de tous les membres exposés à Obj-C, étant donné les inconvénients mentionnés ci-dessus d'avoir des membres inutilement exposés.

Comme documentation officielle Apple . vous devez utiliser @objc pour appeler votre méthode de sélection.

En Objective-C, un sélecteur est un type qui fait référence au nom d'une méthode Objective-C. Dans Swift, les sélecteurs Objective-C sont représentés par la Selectorstructure et peuvent être construits à l'aide de l' #selector expression. Pour créer un sélecteur pour une méthode qui peut être appelée à partir d'Objective-C, transmettez le nom de la méthode, tel que #selector(MyViewController.tappedButton(sender:)). Pour créer un sélecteur pour la méthode de lecture ou de définition Objective-C d'une propriété, transmettez le nom de propriété précédé du libellé getter:ou setter:, tel que #selector(getter: MyViewController.myButton).

À partir de, je pense que Swift 4.2, tout ce que vous avez à faire est d'assigner @IBAction à votre méthode et vous pouvez éviter cette annotation @objc idiote

''

let tap  =  UITapGestureRecognizer(target: self, action: #selector(self.cancel))


@IBAction func cancel()
{
    self.dismiss(animated: true, completion: nil)
}

Comme déjà mentionné dans d'autres réponses, il n'y a aucun moyen d'éviter l' @objcannotation pour les sélecteurs.

Mais l'avertissement mentionné dans l'OP peut être réduit au silence en prenant les mesures suivantes:

1. Accédez aux paramètres de construction
2. Rechercher le mot-clé @objc
3. Définissez la valeur de l' interface Swift 3 @objc surOff

ci-dessous est la capture d'écran qui illustre les étapes mentionnées ci-dessus:

J'espère que cela t'aides

Si vous avez besoin de membres objectif c dans votre contrôleur de vue, ajoutez simplement @objcMembers en haut du contrôleur de vue. Et vous pouvez éviter cela en ajoutant IBAction dans votre code.

@IBAction func buttonAction() {

}

Assurez-vous de connecter cette prise dans le storyboard.