Wie schreibe ich dispatch_after GCD in Swift 3, 4 und 5?

In Swift 2 konnte ich dispatch_aftereine Aktion mit Grand Central Dispatch verzögern:

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 
})

Dies scheint jedoch seit Swift 3 nicht mehr zu kompilieren. Was ist die bevorzugte Methode, um dies im modernen Swift zu schreiben?

Die Syntax lautet einfach:

// to run something in 0.1 seconds

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

Beachten Sie, dass die obige Syntax des Hinzufügens secondsals eine DoubleQuelle der Verwirrung zu sein scheint (insbesondere, da wir es gewohnt waren, ns hinzuzufügen). Diese DoubleSyntax "Sekunden hinzufügen als " funktioniert, weil a deadlineist DispatchTimeund hinter den Kulissen gibt es einen +Operator, der a benötigt Doubleund so viele Sekunden zum DispatchTime:

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

Wenn Sie jedoch wirklich eine Ganzzahl von ms, μs oder ns DispatchTimehinzufügen möchten , können Sie auch a DispatchTimeIntervalzu a hinzufügen DispatchTime. Das heißt, Sie können:

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")
}

Diese funktionieren aufgrund dieser separaten Überladungsmethode für den +Operator in der DispatchTimeKlasse nahtlos .

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

Es wurde gefragt, wie man eine versendete Aufgabe storniert. Verwenden Sie dazu DispatchWorkItem. Dadurch wird beispielsweise eine Aufgabe gestartet, die in fünf Sekunden ausgelöst deinitwird. Wenn der Ansichtscontroller geschlossen und freigegeben wird, wird die Aufgabe abgebrochen :

class ViewController: UIViewController {

    private var item: DispatchWorkItem?

    override func viewDidLoad() {
        super.viewDidLoad()

        item = DispatchWorkItem { [weak self] in
            self?.doSomething()
            self?.item = nil
        }

        DispatchQueue.main.asyncAfter(deadline: .now() + 5, execute: item!)
    }

    deinit {
        item?.cancel()
    }

    func doSomething() { ... }

}

Beachten Sie die Verwendung der [weak self]Erfassungsliste in der DispatchWorkItem. Dies ist wichtig, um einen starken Referenzzyklus zu vermeiden. Beachten Sie auch, dass dies keine vorbeugende Stornierung bewirkt, sondern nur den Start der Aufgabe stoppt, falls dies noch nicht geschehen ist. Wenn es jedoch bereits gestartet ist, als es auf den cancel()Aufruf trifft , beendet der Block seine Ausführung (es sei denn, Sie überprüfen manuell isCancelledinnerhalb des Blocks).

Swift 4:

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

Für die Zeit .seconds(Int), .microseconds(Int)und .nanoseconds(Int)kann auch verwendet werden.

Wenn Sie nur die Verzögerungsfunktion in wollen

Swift 4 & 5

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

Sie können es verwenden wie:

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

Nach der Veröffentlichung von Swift 3 muss auch das @escaping hinzugefügt werden

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

Ein etwas anderer Geschmack der akzeptierten Antwort.

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)")
 }

Swift 4

Sie können eine Erweiterung für DispatchQueue erstellen und eine Funktionsverzögerung hinzufügen, die DispatchQueueintern die asyncAfter-Funktion verwendet

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

und verwenden

DispatchQueue.delay(.milliseconds(10)) {
   print("task to be done")
}

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

Ich würde dringend empfehlen, die Xcode-Tools zum Konvertieren in Swift 3 zu verwenden (Bearbeiten> Konvertieren> In aktuelle Swift-Syntax). Es hat das für mich gefangen

In Swift 4.1 und Xcode 9.4.1

Einfache Antwort ist ...

//To call function after 5 seconds time
DispatchQueue.main.asyncAfter(deadline: .now() + 5.0) {
//Here call your function
}

Swift 5 und höher

DispatchQueue.main.asyncAfter(deadline: .now() + 2, execute: {
   // code to execute                 
})

Keine der genannten Antworten läuft auf einem Nicht-Haupt-Thread, also addiere ich meine 2 Cent.

In der Hauptwarteschlange (Hauptthread)

let mainQueue = DispatchQueue.main
let deadline = DispatchTime.now() + .seconds(10)
mainQueue.asyncAfter(deadline: deadline) {
    // ...
}

ODER

DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + .seconds(10)) { 
    // ...
}

In der globalen Warteschlange (kein Hauptthread, basierend auf der angegebenen QOS).

let backgroundQueue = DispatchQueue.global()
let deadline = DispatchTime.now() + .milliseconds(100)
backgroundQueue.asyncAfter(deadline: deadline, qos: .background) { 
    // ...
}

ODER

DispatchQueue.global().asyncAfter(deadline: DispatchTime.now() + .milliseconds(100), qos: .background) {
    // ...
}

Das hat bei mir in Swift 3 funktioniert

let time1 = 8.23
let time2 = 3.42

// Delay 2 seconds


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

Sie können verwenden

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

Versuche dies

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