Come posso ritardare una chiamata di metodo di 1 secondo?

Esiste un modo semplice per ritardare una chiamata di metodo di 1 secondo?

Ho un oggetto UIImageViewche reagisce a un evento touch. Quando viene rilevato il tocco, nell'app si verificano alcune animazioni. Dopo un secondo, voglio chiamare un altro metodo. In questo caso, non posso usare il animationDidStopselettore.

performSelector:withObject:afterDelay:

Documento di riferimento

Puoi anche usare un blocco

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

Il più delle volte vorrai usare dispatch_get_main_queue, anche se se non ci fosse un'interfaccia utente nel metodo potresti usare una coda globale .

Modificare:

Versione Swift 3:

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

Allo stesso modo, DispatchQueue.global().asyncAfter(...potrebbe anche essere una buona opzione.

Il modo migliore per fare è:

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

puoi anche passare zero come con il parametroObject.

esempio :

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

Ci sono già molte risposte e sono tutte corrette. Nel caso in cui desideri utilizzarlo dispatch_after, dovresti cercare lo snippet che è incluso nella parte Code Snippet Libraryin basso a destra (dove puoi selezionare gli UIelementi).

Quindi devi solo chiamare questo snippet scrivendo invio nel codice:

È possibile utilizzare il selettore di esecuzione per dopo che il metodo di ritardo di 0,1 secondi viene chiamato per il codice seguente per eseguire questa operazione.

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

Puoi anche:

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

In questo caso devi falsificare alcune modifiche in alcune viste per far funzionare l'animazione. È davvero confuso, ma adoro le cose basate sul blocco. O termina la risposta @mcfedr di seguito.

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

Puoi farlo

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

o passare a escaping closure

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

Esiste una soluzione Swift 3 dalla soluzione selezionata:

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

E c'è il metodo

@objc fileprivate func targetMethod(){

}

Utilizzare in Swift 3

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

NOTA: questo metterà in pausa l'intero thread, non solo l'unico metodo.
Effettuare una chiamata in modalità sleep / wait / halt per 1000 ms prima di chiamare il metodo?

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

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

Modifica: la risposta sopra si applica alla domanda generale "Come posso ritardare una chiamata di metodo di 1 secondo?", Che era la domanda posta al momento della risposta (infatti la risposta è stata data entro 7 minuti dalla domanda originale: - )). Non sono state fornite informazioni sulla lingua in quel momento, quindi smetti gentilmente di lamentarti del modo corretto di usare il sonno in XCode della mancanza di lezioni ...