¿Cómo puedo saber si un objeto tiene un observador de valor clave adjunto?

si le dice a un objeto c objetivo que elimine los observadores: para una ruta clave y esa ruta clave no se ha registrado, se quiebran los tristes. me gusta -

"No se puede eliminar un observador para la ruta de acceso clave" theKeyPath "porque no está registrado como observador".

¿Hay alguna manera de determinar si un objeto tiene un observador registrado, por lo que puedo hacer esto

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

Intente atrapar su llamada removeObserver

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

La verdadera pregunta es por qué no sabes si lo estás observando o no.

Si está haciendo esto en la clase del objeto que se está observando, deténgase. Lo que sea que esté observando espera seguir observándolo. Si corta las notificaciones del observador sin su conocimiento, espere que las cosas se rompan; más específicamente, espere que el estado del observador se vuelva obsoleto ya que no recibe actualizaciones del objeto observado anteriormente.

Si está haciendo esto en la clase del objeto de observación, simplemente recuerde qué objetos está observando (o, si solo observa un objeto, ya sea que lo esté observando). Esto supone que la observación es dinámica y entre dos objetos que de otro modo no estarían relacionados; si el observador posee lo observado, simplemente agregue el observador después de crear o retener lo observado, y elimine el observador antes de liberar lo observado.

Agregar y eliminar un objeto como observador generalmente debería ocurrir en la clase del observador, y nunca en la del objeto observado.

FWIW, [someObject observationInfo]parece ser nilsi someObjectno tiene observadores. Sin embargo, no confiaría en este comportamiento, ya que no lo he visto documentado. Además, no sé leer observationInfopara obtener observadores específicos.

La única forma de hacer esto es establecer una bandera cuando agrega un observador.

Cuando agrega un observador a un objeto, puede agregarlo a algo NSMutableArrayasí:

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

Si desea no observar los objetos, puede hacer algo como:

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

Recuerde, si no observa un solo objeto, retírelo de la _observedObjectsmatriz:

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

En mi opinión, esto funciona de manera similar al mecanismo retenerCount. No puede estar seguro de que en el momento actual tenga su observador. Incluso si marca : self.observationInfo : no puede estar seguro de que tendrá / no tendrá observadores en el futuro.

Como retenerCount . Quizás el método observaciónInfo no es exactamente ese tipo de inútil, pero solo lo uso con fines de depuración.

Como resultado, solo tiene que hacerlo como en la administración de memoria. Si agregó un observador, simplemente retírelo cuando no lo necesite. Como usar los métodos viewWillAppear / viewWillDisappear, etc. P.ej:

-(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:@""];
}

Y necesita algunas comprobaciones específicas: implemente su propia clase que maneja una variedad de observadores y úsela para sus comprobaciones.

[someObject observationInfo]regresar nilsi no hay observador.

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

}

El objetivo del patrón de observador es permitir que una clase observada se "selle", para no saber o importar si se está observando. Está intentando explícitamente romper este patrón.

¿Por qué?

El problema que tienes es que estás asumiendo que te están observando cuando no lo estás. Este objeto no inició la observación. Si desea que su clase tenga control de este proceso, entonces debería considerar usar el centro de notificaciones. De esa manera, su clase tiene control total sobre cuándo se pueden observar los datos. Por lo tanto, no le importa quién está mirando.

No soy fanático de esa solución try catch, así que lo que hago la mayor parte del tiempo es crear un método de suscripción y cancelación de suscripción para una notificación específica dentro de esa clase. Por ejemplo, estos dos métodos suscriben o anulan la suscripción del objeto a la notificación global del teclado:

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

Dentro de esos métodos, uso una propiedad privada que se establece en verdadero o falso según el estado de suscripción de la siguiente manera:

@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

Además de la respuesta de Adam, me gustaría sugerir usar macro como esta

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

ejemplo de uso

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