Swift 3.1 déprécie initialize(). Comment puis-je réaliser la même chose ?

Question

Objective-C déclare une fonction de classe, initialize() qui est exécuté une fois pour chaque classe, avant d'être utilisé. Il est souvent utilisé comme point d'entrée pour échanger des implémentations de méthodes (swizzling), entre autres choses.

Swift 3.1 déprécie cette fonction avec un avertissement :

La méthode 'initialize()' définit la méthode de classe Objective-C 'initialize', qui n'est pas garantie d'être invoquée par Swift et qui sera désapprouvée dans les futures versions

Comment résoudre ce problème, tout en conservant le même comportement et les mêmes fonctionnalités que ceux que j'implémente actuellement à l'aide de la fonction initialize() point d'entrée ?

Answer 1

Solution facile/simple

Le point d'entrée commun d'une application est le délégué d'une application. applicationDidFinishLaunching . Nous pourrions simplement ajouter une fonction statique à chaque classe que nous voulons notifier à l'initialisation, et l'appeler d'ici.

Cette première solution est simple et facile à comprendre. Pour la plupart des cas, c'est ce que je recommanderais. Bien que la solution suivante fournisse des résultats plus proches de ceux de la solution originale, elle n'est pas recommandée. initialize() mais le temps de démarrage de l'application s'en trouve légèrement allongé. Je ne pense plus que cela vaut l'effort, la dégradation des performances ou la complexité du code dans la plupart des cas. Un code simple est un bon code.

Lisez la suite pour une autre option. Vous aurez peut-être des raisons d'en avoir besoin (ou peut-être des parties de celle-ci).

---

Une solution pas si simple

La première solution n'est pas forcément adaptée. Et que se passe-t-il si vous construisez un framework, où vous souhaitez que votre code s'exécute sans que personne n'ait besoin de l'appeler depuis le délégué de l'application ?

Première étape

Définissez le code Swift suivant. L'objectif est de fournir un point d'entrée simple pour toute classe que vous souhaitez doter d'un comportement similaire à celui de la classe initialize() - cela peut maintenant être fait simplement en se conformant à SelfAware . Il fournit également une fonction unique pour exécuter ce comportement pour chaque classe conforme.

protocol SelfAware: class {
    static func awake()
}

class NothingToSeeHere {

    static func harmlessFunction() {

        let typeCount = Int(objc_getClassList(nil, 0))
        let types = UnsafeMutablePointer<AnyClass>.allocate(capacity: typeCount)
        let autoreleasingTypes = AutoreleasingUnsafeMutablePointer<AnyClass>(types)
        objc_getClassList(autoreleasingTypes, Int32(typeCount))
        for index in 0 ..< typeCount { (types[index] as? SelfAware.Type)?.awake() }
        types.deallocate(capacity: typeCount)

    }

}

Deuxième étape

Tout cela est bien beau, mais il nous faut encore un moyen d'exécuter la fonction que nous avons définie, c'est-à-dire NothingToSeeHere.harmlessFunction() au démarrage de l'application. Auparavant, cette réponse suggérait d'utiliser le code Objective-C pour ce faire. Cependant, il semble que nous puissions faire ce dont nous avons besoin en utilisant uniquement Swift. Pour macOS ou d'autres plateformes où UIApplication n'est pas disponible, une variation de ce qui suit sera nécessaire.

extension UIApplication {

    private static let runOnce: Void = {
        NothingToSeeHere.harmlessFunction()
    }()

    override open var next: UIResponder? {
        // Called before applicationDidFinishLaunching
        UIApplication.runOnce
        return super.next
    }

}

Troisième étape

Nous disposons maintenant d'un point d'entrée au démarrage de l'application et d'un moyen d'y accéder à partir des classes de votre choix. Tout ce qu'il reste à faire : au lieu d'implémenter initialize() , se conformer à SelfAware et mettre en œuvre la méthode définie, awake() .

Answer 2

Mon approche est essentiellement la même que celle d'adib. Voici un exemple tiré d'une application de bureau qui utilise Core Data ; le but ici est d'enregistrer notre transformateur personnalisé avant que le code ne le mentionne :

@NSApplicationMain
class AppDelegate: NSObject, NSApplicationDelegate {

    override init() {
        super.init()
        AppDelegate.doInitialize
    }

    static let doInitialize : Void = {
        // set up transformer
        ValueTransformer.setValueTransformer(DateToDayOfWeekTransformer(), forName: .DateToDayOfWeekTransformer)
    }()

    // ...
}

Ce qui est bien, c'est que cela fonctionne pour n'importe quelle classe, tout comme initialize a fait, à condition que vous couvriez toutes vos bases - c'est-à-dire que vous devez implémenter chaque initialisateur. Voici un exemple de vue de texte qui configure son propre proxy d'apparence une fois avant que les instances n'aient une chance d'apparaître à l'écran ; l'exemple est artificiel mais l'encapsulation est extrêmement agréable :

class CustomTextView : UITextView {

    override init(frame: CGRect, textContainer: NSTextContainer?) {
        super.init(frame:frame, textContainer: textContainer)
        CustomTextView.doInitialize
    }

    required init?(coder aDecoder: NSCoder) {
        super.init(coder:aDecoder)
        CustomTextView.doInitialize
    }

    static let doInitialize : Void = {
        CustomTextView.appearance().backgroundColor = .green
    }()

}

Cela démontre l'avantage de cette approche bien mieux que ne le fait le délégué d'application. Il n'y a qu'une seule instance de délégué d'application, donc le problème n'est pas très intéressant ; mais il peut y avoir plusieurs instances de CustomTextView. Néanmoins, la ligne CustomTextView.appearance().backgroundColor = .green sera exécuté une seule fois comme le premièrement est créée, car elle fait partie de l'initialisateur d'une propriété statique. Ce comportement est très similaire à celui de la méthode de la classe initialize .

Answer 3

Si vous voulez réparer votre méthode Swizzling dans Pure Swift manière :

public protocol SwizzlingInjection: class {
    static func inject()
}

class SwizzlingHelper {

    private static let doOnce: Any? = {
        UILabel.inject()
        return nil
    }()

    static func enableInjection() {
        _ = SwizzlingHelper.doOnce
    }
}

extension UIApplication {

    override open var next: UIResponder? {
        // Called before applicationDidFinishLaunching
        SwizzlingHelper.enableInjection()
        return super.next
    }

}

extension UILabel: SwizzlingInjection
{
    public static func inject() {
        // make sure this isn't a subclass
        guard self === UILabel.self else { return }

        // Do your own method_exchangeImplementations(originalMethod, swizzledMethod) here

    }
}

Depuis le objc_getClassList est en Objective-C et il ne peut pas récupérer la superclasse (par exemple UILabel) mais seulement toutes les sous-classes, mais pour le swizzling lié à UIKit nous voulons juste l'exécuter une fois sur la superclasse. Il suffit d'exécuter inject() sur chaque classe cible au lieu de for-looping toutes les classes de votre projet.

Answer 4

Vous pouvez également utiliser des variables statiques puisque ceux-là sont déjà paresseux et les référencer dans les initialisateurs de vos objets de haut niveau. Cela serait utile pour les extensions d'applications et autres qui n'ont pas de délégué d'application.

class Foo {
    static let classInit : () = {
        // do your global initialization here
    }()

    init() {
        // just reference it so that the variable is initialized
        Foo.classInit
    }
}

Answer 5

Un léger ajout à l'excellent cours de @JordanSmith qui garantit que chaque awake() n'est appelé qu'une seule fois :

protocol SelfAware: class {
    static func awake()
}

@objc class NothingToSeeHere: NSObject {

    private static let doOnce: Any? = {
        _harmlessFunction()
    }()

    static func harmlessFunction() {
        _ = NothingToSeeHere.doOnce
    }

    private static func _harmlessFunction() {
        let typeCount = Int(objc_getClassList(nil, 0))
        let types = UnsafeMutablePointer<AnyClass>.allocate(capacity: typeCount)
        let autoreleasingTypes = AutoreleasingUnsafeMutablePointer<AnyClass>(types)
        objc_getClassList(autoreleasingTypes, Int32(typeCount))
        for index in 0 ..< typeCount { (types[index] as? SelfAware.Type)?.awake() }
        types.deallocate(capacity: typeCount)
    }
}