dispatch_after - GCD en Swift ?

Question

Je suis passé par le iBook d'Apple, et je n'ai pas trouvé de définition de ce terme :

Quelqu'un peut-il expliquer la structure de dispatch_after ?

dispatch_after(<#when: dispatch_time_t#>, <#queue: dispatch_queue_t?#>, <#block: dispatch_block_t?#>)

Answer 1

J'utilise dispatch_after si souvent que j'ai écrit une fonction utilitaire de haut niveau pour rendre la syntaxe plus simple :

func delay(delay:Double, closure:()->()) {
    dispatch_after(
        dispatch_time(
            DISPATCH_TIME_NOW,
            Int64(delay * Double(NSEC_PER_SEC))
        ),
        dispatch_get_main_queue(), closure)
}

Et maintenant tu peux parler comme ça :

delay(0.4) {
    // do stuff
}

Wow, une langue où vous pouvez améliorer la langue. Qu'est-ce qui pourrait être mieux ?

---

Mise à jour pour Swift 3, Xcode 8 Seed 6

Il semble que cela ne vaille presque plus la peine de s'en préoccuper, maintenant qu'ils ont amélioré la syntaxe d'appel :

func delay(_ delay:Double, closure:@escaping ()->()) {
    let when = DispatchTime.now() + delay
    DispatchQueue.main.asyncAfter(deadline: when, execute: closure)
}

Answer 2

Une idée plus claire de la structure :

dispatch_after(when: dispatch_time_t, queue: dispatch_queue_t, block: dispatch_block_t?)

dispatch_time_t est un UInt64 . Le site dispatch_queue_t est en fait un type aliasé à un NSObject mais vous devriez simplement utiliser vos méthodes GCD habituelles pour obtenir des files d'attente. Le bloc est une fermeture Swift. Plus précisément, dispatch_block_t est défini comme suit () -> Void ce qui est équivalent à () -> () .

Exemple d'utilisation :

let delayTime = dispatch_time(DISPATCH_TIME_NOW, Int64(1 * Double(NSEC_PER_SEC)))
dispatch_after(delayTime, dispatch_get_main_queue()) {
    print("test")
}

EDITAR:

Je recommande d'utiliser @matt est vraiment sympa delay fonction .

EDIT 2 :

Dans Swift 3, il y aura de nouveaux wrappers pour GCD. Voir ici : https://github.com/apple/swift-evolution/blob/master/proposals/0088-libdispatch-for-swift3.md

L'exemple original serait écrit comme suit dans Swift 3 :

let deadlineTime = DispatchTime.now() + .seconds(1)
DispatchQueue.main.asyncAfter(deadline: deadlineTime) {
    print("test")
}

Notez que vous pouvez écrire le deadlineTime déclaration comme DispatchTime.now() + 1.0 et obtenir le même résultat car le + est surchargé comme suit (de la même manière pour - ) :

• func +(time: DispatchTime, seconds: Double) -> DispatchTime
• func +(time: DispatchWalltime, interval: DispatchTimeInterval) -> DispatchWalltime

Cela signifie que si vous n'utilisez pas l'option DispatchTimeInterval enum et que vous écrivez simplement un nombre, il est supposé que vous utilisez les secondes.

Answer 3

Swift 3+

C'est très facile et élégant en Swift 3+ :

DispatchQueue.main.asyncAfter(deadline: .now() + 4.5) {
    // ...
}

Réponse plus ancienne :

Pour développer la réponse de Cezary, qui s'exécute après 1 nanoseconde, j'ai dû faire ce qui suit pour exécuter après 4 secondes et demie.

let delay = 4.5 * Double(NSEC_PER_SEC)
let time = dispatch_time(DISPATCH_TIME_NOW, Int64(delay))
dispatch_after(time, dispatch_get_main_queue(), block)

Edit : J'ai découvert que mon code original était légèrement erroné. Le typage implicite provoque une erreur de compilation si vous ne transformez pas NSEC_PER_SEC en un Double.

Si quelqu'un peut suggérer une solution plus optimale, je serais ravi de l'entendre.

Answer 4

la syntaxe de matt est très agréable et si vous avez besoin d'invalider le bloc, vous pouvez l'utiliser :

typealias dispatch_cancelable_closure = (cancel : Bool) -> Void

func delay(time:NSTimeInterval, closure:()->Void) ->  dispatch_cancelable_closure? {

    func dispatch_later(clsr:()->Void) {
        dispatch_after(
            dispatch_time(
                DISPATCH_TIME_NOW,
                Int64(time * Double(NSEC_PER_SEC))
            ),
            dispatch_get_main_queue(), clsr)
    }

    var closure:dispatch_block_t? = closure
    var cancelableClosure:dispatch_cancelable_closure?

    let delayedClosure:dispatch_cancelable_closure = { cancel in
        if closure != nil {
            if (cancel == false) {
                dispatch_async(dispatch_get_main_queue(), closure!);
            }
        }
        closure = nil
        cancelableClosure = nil
    }

    cancelableClosure = delayedClosure

    dispatch_later {
        if let delayedClosure = cancelableClosure {
            delayedClosure(cancel: false)
        }
    }

    return cancelableClosure;
}

func cancel_delay(closure:dispatch_cancelable_closure?) {

    if closure != nil {
        closure!(cancel: true)
    }
}

Utilisez comme suit

let retVal = delay(2.0) {
    println("Later")
}
delay(1.0) {
    cancel_delay(retVal)
}

crédits

_Le lien ci-dessus semble être en panne. Code original Objc de Github_

Answer 5

Une autre façon est d'étendre Double comme ceci :

extension Double {
   var dispatchTime: dispatch_time_t {
       get {
           return dispatch_time(DISPATCH_TIME_NOW,Int64(self * Double(NSEC_PER_SEC)))
       }
   }
}

Alors vous pouvez l'utiliser comme ceci :

dispatch_after(Double(2.0).dispatchTime, dispatch_get_main_queue(), { () -> Void in
            self.dismissViewControllerAnimated(true, completion: nil)
    })

J'aime la fonction de retardement de Matt mais, par préférence, je préfère limiter les fermetures de passage.