Come eseguire le richiamate in Objective-C

Question

Come eseguire le funzioni di richiamata in Objective-C?

Vorrei solo vedere alcuni esempi completati e dovrei capirlo.

Answer 1

Normalmente, le richiamate nell'obiettivo C vengono eseguite con i delegati. Ecco un esempio di implementazione personalizzata dei delegati;

/// Header File 
@interface MyClass : NSObject { 
    id delegate; 
} 
- (void)setDelegate:(id)delegate; 
- (void)doSomething; 
@end 

@interface NSObject(MyDelegateMethods) 
- (void)myClassWillDoSomething:(MyClass *)myClass; 
- (void)myClassDidDoSomething:(MyClass *)myClass; 
@end 


/// Message (.m) File 
@implementation MyClass 
- (void)setDelegate:(id)aDelegate { 
    delegate = aDelegate; /// Not retained 
} 

- (void)doSomething { 
    [delegate myClassWillDoSomething:self]; 
    /* DO SOMETHING */ 
    [delegate myClassDidDoSomething:self]; 
} 
@end 

Che illustra l'approccio generale. Si crea una categoria su NSObject che dichiara i nomi dei metodi di callback. NSObject in realtà non implementa questi metodi. Questo tipo di categoria è chiamato protocollo informale, stai solo dicendo che molti oggetti potrebbero implementare questi metodi. Sono un modo per inoltrare la dichiarazione del tipo del selettore.

Successivamente si ha qualche oggetto come delegato di "MyClass" e MyClass chiama i metodi delegati sul delegato come appropriato. Se i callback dei delegati sono opzionali, generalmente li proteggi nel sito di spedizione con qualcosa come "if ([delegate respondsToSelector: @selector (myClassWillDoSomething :)) {". Nel mio esempio, al delegato è richiesto di implementare entrambi i metodi.

Invece di un protocollo informale, è possibile utilizzare anche un protocollo formale definito con @protocol. Se lo fai, cambieresti il ​​tipo del setter delegato e la variabile di istanza fosse "id <MyClassDelegate>" invece di "id".

Inoltre, si noterà che il delegato non viene mantenuto. Questo in genere viene eseguito perché l'oggetto che "possiede" istanze di "MyClass" è in genere anche il delegato. Se MyClass ha mantenuto il suo delegato, allora ci sarebbe un ciclo di conservazione. È una buona idea nel metodo dealloc di una classe che abbia un'istanza MyClass ed è il suo delegato a cancellare quel riferimento delegato poiché è un debole back pointer. Altrimenti, se qualcosa mantiene in vita l'istanza di MyClass, avrai un puntatore pendente.

Answer 2

Ecco un esempio che mantiene i concetti dei delegati e fa semplicemente una chiamata non valida.

@interface Foo : NSObject { 
} 
- (void)doSomethingAndNotifyObject:(id)object withSelector:(SEL)selector; 
@end 

@interface Bar : NSObject { 
} 
@end 

@implementation Foo 
- (void)doSomethingAndNotifyObject:(id)object withSelector:(SEL)selector { 
    /* do lots of stuff */ 
    [object performSelector:selector withObject:self]; 
} 
@end 

@implementation Bar 
- (void)aMethod { 
    Foo *foo = [[[Foo alloc] init] autorelease]; 
    [foo doSomethingAndNotifyObject:self withSelector:@selector(fooIsDone:)]; 
} 

- (void)fooIsDone:(id)sender { 
    NSLog(@"Foo Is Done!"); 
} 
@end 

genere il metodo - [Foo doSomethingAndNotifyObject: withSelector:] sarebbe asincrona che rendono la richiamata più utile è qui.

Answer 3

Per completezza, dal momento che StackOverflow RSS resuscitato appena a caso la questione per me, l'altra opzione (più recente) è quello di utilizzare i blocchi:

@interface MyClass: NSObject 
{ 
    void (^_completionHandler)(int someParameter); 
} 

- (void) doSomethingWithCompletionHandler:(void(^)(int))handler; 
@end 


@implementation MyClass 

- (void) doSomethingWithCompletionHandler:(void(^)(int))handler 
{ 
    // NOTE: copying is very important if you'll call the callback asynchronously, 
    // even with garbage collection! 
    _completionHandler = [handler copy]; 

    // Do stuff, possibly asynchronously... 
    int result = 5 + 3; 

    // Call completion handler. 
    _completionHandler(result); 

    // Clean up. 
    [_completionHandler release]; 
    _completionHandler = nil; 
} 

@end 

... 

MyClass *foo = [[MyClass alloc] init]; 
int x = 2; 
[foo doSomethingWithCompletionHandler:^(int result){ 
    // Prints 10 
    NSLog(@"%i", x + result); 
}]; 

Answer 4

Per mantenere questa domanda up-to-date, di iOS 5.0 introduzione di ARC significa che questo può essere realizzato utilizzando Blocks ancora più conciso:

@interface Robot: NSObject 
+ (void)sayHi:(void(^)(NSString *))callback; 
@end 

@implementation Robot 
+ (void)sayHi:(void(^)(NSString *))callback { 
    // Return a message to the callback 
    callback(@"Hello to you too!"); 
} 
@end 

[Robot sayHi:^(NSString *reply){ 
    NSLog(@"%@", reply); 
}]; 

C'è sempre F****ng Block Syntax se mai dimenticare la sintassi del blocco di Objective-C.

Answer 5

CallBack: Ci sono 4 tipi di callback in Objective C

1. Tipo Selettore: Si può vedere NSTimer, UIPangesture sono gli esempi di Selettore di callback. Utilizzato per l'esecuzione di codice molto limitata.

2. Tipo di delegato: comune e più utilizzato nel framework Apple. UITableViewDelegate, NSNURLConnectionDelegate. Essi sono di solito utilizzati per mostrare molte immagini Download da server in modo asincrono ecc

3. NSNotifications: NotificationCenter è una delle caratteristiche di Objective C che ha usato per comunicare molte receiptants al momento in cui si verificano eventi.
4. Blocchi: i blocchi sono più comunemente utilizzati nella programmazione in Objective C. È una funzione eccezionale e viene utilizzata per eseguire blocchi di codice. Puoi anche riferirti all'esercitazione per capire: Blocks tutorial

Per favore lasciatemi se ci sono altre risposte. Io lo apprezzerei.