Wie man Methode Swizzling Swift 3.0 implementieren?

Wie kann ich eine Methode implementieren swizzling in Swift 3.0 ?

Habe ich gelesen nshipster Artikel darüber, aber in diesem code - chunk

struct Static {
    static var token: dispatch_once_t = 0
}

der compiler gibt mir eine Fehlermeldung

dispatch_once_t ist nicht verfügbar in Swift: Verwenden Sie träge initialisiert
globals statt

Kommentar zu dem Problem - Öffnen

Die Fehlermeldung ist ein bisschen stumpf; es ist in Ordnung, verwenden Sie ein static - Variablen, die als static - Variablen werden automatisch erstellt, genau sobald, die Auftritt, wenn Sie das erste mal zugegriffen wird (d.h., träge). static var token = 0 ist der richtige Weg, dies zu tun in Swift 3. Quelle Kommentarautor: BallpointBen

InformationsquelleAutor der Frage Tikhonov Alexander | 2016-09-18

Zunächst dispatch_once_t ist nicht verfügbar in Swift 3.0.
Sie können wählen Sie aus zwei alternativen:

Globale variable
Statische Eigenschaft struct, enum oder class

Für mehr details, sehen, dass Wohin dispatch_once in Swift 3

Für verschiedene Zwecke, müssen Sie verwenden unterschiedliche Umsetzung von swizzling

Swizzling Cocoa-Touch-Klasse, zum Beispiel UIViewController;

Swizzling benutzerdefinierte Swift Klasse;

Swizzling Cocoa-Touch-Klasse

Beispiel swizzling viewWillAppear(_:) von UIViewController Verwendung von globalen Variablen

private let swizzling: (UIViewController.Type) -> () = { viewController in

    let originalSelector = #selector(viewController.viewWillAppear(_:))
    let swizzledSelector = #selector(viewController.proj_viewWillAppear(animated:))

    let originalMethod = class_getInstanceMethod(viewController, originalSelector)
    let swizzledMethod = class_getInstanceMethod(viewController, swizzledSelector)

    method_exchangeImplementations(originalMethod, swizzledMethod) }

extension UIViewController {

    open override class func initialize() {
        //make sure this isn't a subclass
        guard self === UIViewController.self else { return }
        swizzling(self)
    }

    //MARK: - Method Swizzling

    func proj_viewWillAppear(animated: Bool) {
        self.proj_viewWillAppear(animated: animated)

        let viewControllerName = NSStringFromClass(type(of: self))
        print("viewWillAppear: \(viewControllerName)")
    } 
 }

Swizzling benutzerdefinierte Swift-Klasse

Verwenden Methode swizzling mit Ihrer Swift-Klassen es gibt zwei Anforderungen, die Sie erfüllen müssen (für mehr details):

Die Klasse enthält die Methoden, die in der swizzled erweitern müssen NSObject
Die Methoden, die Sie möchten swizzle muss die dynamic Attribut

Und Beispiel swizzling-Methode der benutzerdefinierten Swift base Klasse Person

class Person: NSObject {
    var name = "Person"
    dynamic func foo(_ bar: Bool) {
        print("Person.foo")
    }
}

class Programmer: Person {
    override func foo(_ bar: Bool) {
        super.foo(bar)
        print("Programmer.foo")
    }
}

private let swizzling: (Person.Type) -> () = { person in

    let originalSelector = #selector(person.foo(_:))
    let swizzledSelector = #selector(person.proj_foo(_:))

    let originalMethod = class_getInstanceMethod(person, originalSelector)
    let swizzledMethod = class_getInstanceMethod(person, swizzledSelector)

    method_exchangeImplementations(originalMethod, swizzledMethod)
}

extension Person {

    open override class func initialize() {
        //make sure this isn't a subclass
        guard self === Person.self else { return }
        swizzling(self)
    }

    //MARK: - Method Swizzling

    func proj_foo(_ bar: Bool) {
        self.proj_foo(bar)

        let className = NSStringFromClass(type(of: self))
        print("class: \(className)")
    }
}

InformationsquelleAutor der Antwort Tikhonov Alexander

@TikhonovAlexander: Super Antwort,

Modifizierte ich die swizzler beide Selektoren und machte es mehr generische.

Swift 3

private let swizzling: (AnyClass, Selector, Selector) -> () = { forClass, originalSelector, swizzledSelector in
    let originalMethod = class_getInstanceMethod(forClass, originalSelector)
    let swizzledMethod = class_getInstanceMethod(forClass, swizzledSelector)
    method_exchangeImplementations(originalMethod, swizzledMethod)
}

//perform swizzling in initialize()

extension UIView {

    open override class func initialize() {
        //make sure this isn't a subclass
        guard self === UIView.self else { return }

        let originalSelector = #selector(layoutSubviews)
        let swizzledSelector = #selector(swizzled_layoutSubviews)
        swizzling(self, originalSelector, swizzledSelector)
    }

    func swizzled_layoutSubviews() {
        swizzled_layoutSubviews()
        print("swizzled_layoutSubviews")
    }

}

Swift 4

private let swizzling: (AnyClass, Selector, Selector) -> () = { forClass, originalSelector, swizzledSelector in
    let originalMethod = class_getInstanceMethod(forClass, originalSelector)
    let swizzledMethod = class_getInstanceMethod(forClass, swizzledSelector)
    method_exchangeImplementations(originalMethod, swizzledMethod)
}

extension UIView {

    static let classInit: Void = {            
        let originalSelector = #selector(layoutSubviews)
        let swizzledSelector = #selector(swizzled_layoutSubviews)
        swizzling(UIView.self, originalSelector, swizzledSelector)
    }()

    func swizzled_layoutSubviews() {
        swizzled_layoutSubviews()
        print("swizzled_layoutSubviews")
    }

}

//perform swizzling in AppDelegate.init()

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    override init() {
        super.init()
        UIView.classInit
    }

}

InformationsquelleAutor der Antwort efremidze

swizzling Spielplatz

class TestSwizzling : NSObject {
    dynamic func methodOne()->Int{
    return 1
}
}

extension TestSwizzling {

//In Objective-C you'd perform the swizzling in load(),
//but this method is not permitted in Swift
func initialize1()
{


    let i: () -> () = {


        let originalSelector = #selector(TestSwizzling.methodOne)
        let swizzledSelector = #selector(TestSwizzling.methodTwo)
        let originalMethod = class_getInstanceMethod(TestSwizzling.self, originalSelector);
        let swizzledMethod = class_getInstanceMethod(TestSwizzling.self, swizzledSelector)
        method_exchangeImplementations(originalMethod, swizzledMethod)
        print("swizzled")

    }
    i()
}

func methodTwo()->Int{
    //It will not be a recursive call anymore after the swizzling
    return 4
}
}

var c = TestSwizzling()
c.initialize1()
print(c.methodOne())
print(c.methodTwo())

Ausgabe:
4
1

InformationsquelleAutor der Antwort Dharay Mistry

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.