Come posso sapere se a un oggetto è associato un osservatore di valori-chiave

se si dice a un oggetto c obiettivo di rimuovereObservers: per un percorso chiave e quel percorso chiave non è stato registrato, si spezza la tristezza. piace -

"Impossibile rimuovere un osservatore per il percorso chiave" theKeyPath "perché non è registrato come osservatore."

c'è un modo per determinare se un oggetto ha un osservatore registrato, quindi posso farlo

if (object has observer){
  remove observer
}
else{
  go on my merry way
}

Prova a aggirare la tua chiamata removeObserver

@try{
   [someObject removeObserver:someObserver forKeyPath:somePath];
}@catch(id anException){
   //do nothing, obviously it wasn't attached because an exception was thrown
}

La vera domanda è perché non sai se la stai osservando o no.

Se lo stai facendo nella classe dell'oggetto osservato, fermati. Qualunque cosa stia osservando, si aspetta che continui ad osservarlo. Se tagli le notifiche dell'osservatore a sua insaputa, ti aspetti che le cose si rompano; più specificamente, aspettatevi che lo stato dell'osservatore diventi stantio poiché non riceve aggiornamenti dall'oggetto precedentemente osservato.

Se lo stai facendo nella classe dell'oggetto osservatore, ricorda semplicemente quali oggetti stai osservando (o, se osservi solo un oggetto, se lo stai osservando). Ciò presuppone che l'osservazione sia dinamica e tra due oggetti altrimenti non correlati; se l'osservatore possiede l'osservato, basta aggiungere l'osservatore dopo aver creato o conservare l'osservato e rimuovere l'osservatore prima di rilasciare l'osservato.

L'aggiunta e la rimozione di un oggetto come osservatore dovrebbe generalmente avvenire nella classe dell'osservatore e mai in quella osservata.

FWIW, [someObject observationInfo]sembra essere nilse someObjectnon ha osservatori. Non mi fiderei di questo comportamento, tuttavia, poiché non l'ho visto documentato. Inoltre, non so leggere observationInfoper ottenere osservatori specifici.

L'unico modo per farlo è impostare un flag quando aggiungi un osservatore.

Quando aggiungi un osservatore a un oggetto, puoi aggiungerlo a un NSMutableArraysimile:

- (void)addObservedObject:(id)object {
    if (![_observedObjects containsObject:object]) {
        [_observedObjects addObject:object];
    }
}

Se vuoi non rispettare gli oggetti, puoi fare qualcosa del tipo:

for (id object in _observedObjects) {
    if ([object isKindOfClass:[MyClass class]]) {
        MyClass *myObject = (MyClass *)object;
        [self unobserveMethod:myObject];
    }
}
[_observedObjects removeAllObjects];

Ricorda, se non osservi un singolo oggetto rimuovilo _observedObjectsdall'array:

- (void)removeObservedObject:(id)object {
    if ([_observedObjects containsObject:object]) {
        [_observedObjects removeObject:object];
    }
}

Secondo me, funziona in modo simile al meccanismo retainCount. Non puoi essere sicuro che al momento hai il tuo osservatore. Anche se controlli: self.observationInfo - non puoi sapere con certezza che avrai / non avrai osservatori in futuro.

Come retainCount . Forse l' osservazioneInfo metodo non è esattamente quel tipo di inutile, ma lo uso solo a scopi di debug.

Di conseguenza, devi solo farlo come nella gestione della memoria. Se hai aggiunto un osservatore, rimuovilo quando non ti serve. Come usare i metodi viewWillAppear / viewWillDisappear ecc. Per esempio:

-(void) viewWillAppear:(BOOL)animated
{
    [super viewWillAppear:animated];
    [self addObserver:nil forKeyPath:@"" options:NSKeyValueObservingOptionNew context:nil];
}

-(void) viewWillDisappear:(BOOL)animated
{
    [super viewWillDisappear:animated];
    [self removeObserver:nil forKeyPath:@""];
}

E hai bisogno di alcuni controlli specifici: implementa la tua classe che gestisce un array di osservatori e lo usa per i tuoi controlli.

[someObject observationInfo]ritorna nilse non c'è osservatore.

if ([tableMessage observationInfo] == nil)
{
   NSLog(@"add your observer");
}
else
{
  NSLog(@"remove your observer");

}

Il punto centrale del modello di osservatore è quello di consentire a una classe osservata di essere "sigillata" - di non sapere o preoccuparsi se viene osservata. Stai esplicitamente cercando di rompere questo schema.

Perché?

Il problema che stai riscontrando è che stai assumendo di essere osservato quando non lo sei. Questo oggetto non ha avviato l'osservazione. Se vuoi che la tua classe abbia il controllo di questo processo, allora dovresti prendere in considerazione l'uso del centro di notifica. In questo modo la tua classe ha il pieno controllo su quando è possibile osservare i dati. Quindi, non importa chi sta guardando.

Non sono un fan di quella soluzione di prova, quindi quello che faccio la maggior parte delle volte è che creo un metodo di iscrizione e annullamento dell'iscrizione per una specifica notifica all'interno di quella classe. Ad esempio, questi due metodi sottoscrivono o annullano la sottoscrizione dell'oggetto alla notifica della tastiera globale:

@interface ObjectA : NSObject
-(void)subscribeToKeyboardNotifications;
-(void)unsubscribeToKeyboardNotifications;
@end

All'interno di questi metodi utilizzo una proprietà privata impostata su true o false a seconda dello stato dell'abbonamento in questo modo:

@interface ObjectA()
@property (nonatomic,assign) BOOL subscribedToKeyboardNotification
@end

@implementation

-(void)subscribeToKeyboardNotifications {
    if (!self.subscribedToKeyboardNotification) {
        [[NSNotificationCenter defaultCenter]addObserver:self selector:@selector(onKeyboardShow:) name:UIKeyboardWillShowNotification object:nil];
        [[NSNotificationCenter defaultCenter]addObserver:self selector:@selector(onKeyboardHide:) name:UIKeyboardWillHideNotification object:nil];
        self.subscribedToKeyboardNotification = YES;
    }
}

-(void)unsubscribeToKeyboardNotifications {
    if (self.subscribedToKeyboardNotification) {
        [[NSNotificationCenter defaultCenter]removeObserver:self name:UIKeyboardWillShowNotification object:nil];
        [[NSNotificationCenter defaultCenter]removeObserver:self name:UIKeyboardWillHideNotification object:nil];
        self.subscribedToKeyboardNotification = NO;
    }
}
@end

Oltre alla risposta di Adam, vorrei suggerire di utilizzare macro come questa

#define SafeRemoveObserver(sender, observer, keyPath) \
@try{\
   [sender removeObserver:observer forKeyPath:keyPath];\
}@catch(id anException){\
}

esempio di utilizzo

- (void)dealloc {
    SafeRemoveObserver(someObject, self, somePath);
}