Wie kann ich einen Methodenaufruf um 1 Sekunde verzögern?

Gibt es eine einfache Möglichkeit, einen Methodenaufruf um 1 Sekunde zu verzögern?

Ich habe eine UIImageView, die auf ein Berührungsereignis reagiert. Wenn die Berührung erkannt wird, werden einige Animationen in der App ausgeführt. Nach einer Sekunde möchte ich eine andere Methode aufrufen. In diesem Fall kann ich den animationDidStopSelektor nicht verwenden .

performSelector:withObject:afterDelay:

Dokumentverweis

Sie können auch einen Block verwenden

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 1 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
    [object method]; 
});

Meistens möchten Sie dispatch_get_main_queue verwenden. Wenn die Methode jedoch keine Benutzeroberfläche enthält, können Sie eine globale Warteschlange verwenden .

Bearbeiten:

Swift 3 Version:

DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
    object.method()
}

Ebenso DispatchQueue.global().asyncAfter(...könnte auch eine gute Option sein.

Der beste Weg ist:

[self performSelector:@selector(YourFunctionName) 
           withObject:(can be Self or Object from other Classes) 
           afterDelay:(Time Of Delay)];

Sie können nil auch als withObject-Parameter übergeben.

Beispiel:

[self performSelector:@selector(subscribe) withObject:self afterDelay:3.0 ];

Es gibt bereits viele Antworten und alle sind richtig. Wenn Sie das verwenden möchten, dispatch_aftersollten Sie nach dem Snippet suchen, Code Snippet Librarydas rechts unten im enthalten ist (wo Sie die UIElemente auswählen können ).

Sie müssen dieses Snippet also nur aufrufen, indem Sie den Versand in Code schreiben :

Sie können den Perform-Selektor verwenden, nachdem die 0,1-Sekunden-Verzögerungsmethode den folgenden Code aufgerufen hat, um dies zu tun.

[self performSelector:@selector(InsertView)  withObject:nil afterDelay:0.1]; 

Du kannst auch:

[UIView animateWithDuration:1.0
                 animations:^{ self.view.alpha = 1.1; /* Some fake chages */ }
                 completion:^(BOOL finished)
{
    NSLog(@"A second lapsed.");
}];

In diesem Fall müssen Sie einige Änderungen an einer Ansicht vortäuschen, damit die Animation funktioniert. Es ist zwar hackig, aber ich liebe das blockbasierte Zeug. Oder schließen Sie die Antwort von @mcfedr unten ab.

waitFor(1.0, ^
{
    NSLog(@"A second lapsed");
});

typedef void (^WaitCompletionBlock)();
void waitFor(NSTimeInterval duration, WaitCompletionBlock completion)
{
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, duration * NSEC_PER_SEC),
                   dispatch_get_main_queue(), ^
    { completion(); });
}

Du kannst das

[self performSelector:@selector(MethodToExecute) withObject:nil afterDelay:1.0 ];

Swift 2.x.

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

Swift 3.x - & - Swift 4

DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
    print("do some work")
}

oder pass a escaping closure

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

Es gibt eine Swift 3-Lösung aus der überprüften Lösung:

self.perform(#selector(self.targetMethod), with: self, afterDelay: 1.0)

Und da ist die Methode

@objc fileprivate func targetMethod(){

}

Verwendung in Swift 3

perform(<Selector>, with: <object>, afterDelay: <Time in Seconds>)

HINWEIS: Dadurch wird Ihr gesamter Thread angehalten, nicht nur die eine Methode.
Rufen Sie 1000 ms lang an, um zu schlafen / warten / anhalten, bevor Sie Ihre Methode aufrufen?

Sleep(1000); // does nothing the next 1000 mSek

Methodcall(params); // now do the real thing

Bearbeiten: Die obige Antwort gilt für die allgemeine Frage "Wie kann ich einen Methodenaufruf um 1 Sekunde verzögern?", Die zum Zeitpunkt der Antwort gestellt wurde (tatsächlich wurde die Antwort innerhalb von 7 Minuten nach der ursprünglichen Frage gegeben: - )). Zu dieser Zeit wurden keine Informationen über die Sprache gegeben. Hören Sie also bitte auf, sich über die richtige Art und Weise der Verwendung von Schlaf zu beschweren.