Comment écrire dispatch_after GCD dans Swift 3 et 4?

Question

Swift 2, j'ai pu utiliser dispatch_after pour retarder une action en utilisant grande expédition centrale:

var dispatchTime: dispatch_time_t = dispatch_time(DISPATCH_TIME_NOW, Int64(0.1 * Double(NSEC_PER_SEC))) 
dispatch_after(dispatchTime, dispatch_get_main_queue(), { 
    // your function here 
}) 

Mais cela ne semble plus compiler Swift 3 (ou 4). Quel est le moyen préféré d'écrire ceci dans Swift 3 (en utilisant la nouvelle API Dispatch)?

Answer 1

La syntaxe est simplement:

// to run something in 0.1 seconds 

DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { 
    // your code here 
} 

---

Notez la syntaxe ci-dessus d'ajouter seconds comme Double semble être une source de confusion (en particulier parce que nous étions habitués à ajouter nsec). « AJOUT secondes comme Double » fonctionne syntaxe parce deadline est un DispatchTime et, dans les coulisses, il y a un opérateur + qui prendra un Double et d'ajouter que de nombreuses secondes à la DispatchTime:

public func +(time: DispatchTime, seconds: Double) -> DispatchTime 

Mais, si vous voulez vraiment ajouter un nombre entier de msec, μs ou nsec au DispatchTime, vous pouvez également ajouter un DispatchTimeInterval à un DispatchTime. Cela signifie que vous pouvez faire:

DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(500)) { 
    os_log("500 msec seconds later") 
} 

DispatchQueue.main.asyncAfter(deadline: .now() + .microseconds(1_000_000)) { 
    os_log("1m μs seconds later") 
} 

DispatchQueue.main.asyncAfter(deadline: .now() + .nanoseconds(1_500_000_000)) { 
    os_log("1.5b nsec seconds later") 
} 

Tous ces fonctionnent de manière transparente en raison de cette méthode de surcharge distincte pour l'opérateur + dans la classe DispatchTime.

public func +(time: DispatchTime, interval: DispatchTimeInterval) -> DispatchTime 

Answer 2

appel DispatchQueue.main.after(when: DispatchTime, execute:() -> Void)

Je recommande fortement d'utiliser les outils Xcode pour convertir à Swift 3 (Edition> Convertir> Pour Swift Current Syntax). Il a pris pour moi

Answer 3

Swift 4:

DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(100)) { 
    // Code 
} 

Pour le moment .seconds(Int), .microseconds(Int) et .nanoseconds(Int) peuvent également être utilisés.

Answer 4

Si vous voulez juste la fonction de retard dans

Swift 4

func delay(delay: Double, closure: @escaping() ->()) { 

    DispatchQueue.main.asyncAfter(deadline: .now() + delay) { 
      closure() 
    } 
} 

Vous pouvez l'utiliser comme:

delay(delay: 1) { 
    print("Hi!") 
} 

Answer 5

après la libération rapide de 3, également @escaping a à ajouter

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

Answer 6

Cela a fonctionné pour moi dans Swift 3

let time1 = 8.23 
let time2 = 3.42 

// Delay 2 seconds 


DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) { 
    print("Sum of times: \(time1 + time2)") 
} 

Answer 7

Vous pouvez créer une fonction performAfter qui utilise la fonction Swift 3 de DispatchAfter interne

func performAfter(delay: TimeInterval, completion: @escaping() -> Void) { 
    DispatchQueue.main.asyncAfter(deadline: .now() + delay) { 
     completion() 
    } 
} 

et utiliser

performAfter(delay: 2) { 
    print("task to be done") 
} 

Answer 8

Vous pouvez utiliser

DispatchQueue.main.asyncAfter(deadline: .now() + .microseconds(100)) { 
     // Code 
    } 

Answer 9

Une saveur quelque peu différente de la réponse acceptée.

Swift 4

DispatchQueue.main.asyncAfter(deadline: .now() + 0.1 + .milliseconds(500) + 
.microseconds(500) + .nanoseconds(1000)) { 
       print("Delayed by 0.1 second + 500 milliseconds + 500 microseconds + 
         1000 nanoseconds)") 
} 

Answer 10

essayer

let when = DispatchTime.now() + 1.5 
    DispatchQueue.main.asyncAfter(deadline: when) { 
     //some code 
    }