Objective-C: Onde remover o observador para NSNotification?

Eu tenho uma classe C objetiva. Nele, criei um método init e configurei um NSNotification nele

//Set up NSNotification
[[NSNotificationCenter defaultCenter] addObserver:self 
                                         selector:@selector(getData)
                                             name:@"Answer Submitted"
                                           object:nil];

Onde eu defino o [[NSNotificationCenter defaultCenter] removeObserver:self]nesta classe? Eu sei que para a UIViewController, posso adicioná-la ao viewDidUnloadmétodo. Então, o que precisa ser feito se eu acabo de criar uma classe c objetiva?

A resposta genérica seria "assim que você não precisar mais das notificações". Obviamente, esta não é uma resposta satisfatória.

Eu recomendo que você adicione um [notificationCenter removeObserver: self]método deallocde chamada dessas classes, que você pretende usar como observadores, pois é a última chance de cancelar o registro de um observador de forma limpa. Isso, no entanto, apenas o protegerá contra travamentos devido ao centro de notificação notificando objetos mortos. Ele não pode proteger seu código contra o recebimento de notificações, quando seus objetos ainda não estão / não estão mais em um estado em que possam lidar adequadamente com a notificação. Para isso ... Veja acima.

Editar (já que a resposta parece atrair mais comentários do que eu pensava) Tudo o que estou tentando dizer aqui é: é realmente difícil dar um conselho geral sobre quando é melhor remover o observador do centro de notificação, porque isso depende:

• No seu caso de uso (quais notificações são observadas? Quando elas são enviadas?)
• A implementação do observador (quando está pronto para receber notificações? Quando não está mais pronto?)
• O tempo de vida pretendido do observador (está vinculado a algum outro objeto, digamos, uma visualização ou controlador de visualização?)
• ...

Portanto, o melhor conselho geral que posso dar: para proteger seu aplicativo. contra pelo menos uma possível falha, faça a removeObserver:dança dealloc, já que esse é o último ponto (na vida do objeto), onde você pode fazer isso de forma limpa. O que isso não significa é: "adie a remoção até que deallocseja chamado, e tudo ficará bem". Em vez disso, remova o observador assim que o objeto não estiver mais pronto (ou necessário) para receber notificações . Esse é o momento certo. Infelizmente, por não saber as respostas a nenhuma das perguntas mencionadas acima, não posso nem imaginar quando seria esse momento.

Você sempre pode proteger removeObserver:um objeto várias vezes (e todas, exceto a primeira chamada com um determinado observador, serão nops). Então: pense em fazer (de novo) deallocapenas para ter certeza, mas antes de mais nada: faça no momento apropriado (que é determinado pelo seu caso de uso).

Nota: Isso foi testado e funcionando 100% por cento

Rápido

override func viewWillDisappear(animated: Bool){
    super.viewWillDisappear(animated)

    if self.navigationController!.viewControllers.contains(self) == false  //any other hierarchy compare if it contains self or not
    {
        // the view has been removed from the navigation stack or hierarchy, back is probably the cause
        // this will be slow with a large stack however.

        NSNotificationCenter.defaultCenter().removeObserver(self)
    }
}

PresentedViewController

override func viewWillDisappear(animated: Bool){
    super.viewWillDisappear(animated)

    if self.isBeingDismissed()  //presented view controller
    {
        // remove observer here
        NSNotificationCenter.defaultCenter().removeObserver(self)
    }
}

Objective-C

Em iOS 6.0 > version, é melhor remover o observador em viewWillDisappearporque o viewDidUnloadmétodo está obsoleto.

 [[NSNotificationCenter defaultCenter] removeObserver:observerObjectHere];

Muitas vezes é melhor remove observerquando a visão é removida do navigation stack or hierarchy.

- (void)viewWillDisappear:(BOOL)animated{
 if (![[self.navigationController viewControllers] containsObject: self]) //any other hierarchy compare if it contains self or not
    {
        // the view has been removed from the navigation stack or hierarchy, back is probably the cause
        // this will be slow with a large stack however.

        [[NSNotificationCenter defaultCenter] removeObserver:observerObjectHere];
    }
}

PresentedViewController

- (void)viewWillDisappear:(BOOL)animated{
    if ([self isBeingDismissed] == YES) ///presented view controller
    {
        // remove observer here
        [[NSNotificationCenter defaultCenter] removeObserver:observerObjectHere];
    }
}

Desde o iOS 9 não é mais necessário remover observadores.

No OS X 10.11 e iOS 9.0, NSNotificationCenter e NSDistributedNotificationCenter não enviará mais notificações para observadores registrados que podem ser desalocados.

https://developer.apple.com/library/mac/releasenotes/Foundation/RN-Foundation/index.html#10_11NotificationCenter

Se o observador for adicionado a um controlador de visualização , recomendo fortemente adicioná-lo viewWillAppeare removê-lo viewWillDisappear.

-(void) dealloc {
      [[NSNotificationCenter defaultCenter] removeObserver:self];
      [super dealloc];
}

Em geral, eu coloco no deallocmétodo.

Em swift, use deinit porque o dealloc não está disponível:

deinit {
    ...
}

Documentação do Swift:

Um desinicializador é chamado imediatamente antes de uma instância de classe ser desalocada. Você escreve deinitializers com a palavra-chave deinit, semelhante a como os inicializadores são escritos com a palavra-chave init. Os desinicializadores estão disponíveis apenas em tipos de classe.

Normalmente, você não precisa realizar uma limpeza manual quando suas instâncias são desalocadas. No entanto, quando estiver trabalhando com seus próprios recursos, pode ser necessário realizar alguma limpeza adicional. Por exemplo, se você criar uma classe personalizada para abrir um arquivo e gravar alguns dados nele, pode ser necessário fechar o arquivo antes que a instância da classe seja desalocada.

* editar: Este conselho se aplica ao iOS <= 5 (mesmo lá você deve adicionar viewWillAppeare remover viewWillDisappear- no entanto, o conselho se aplica se por algum motivo você adicionou o observador emviewDidLoad )

Se você adicionou o observador em, viewDidLoaddeve removê-lo em ambos dealloce viewDidUnload. Caso contrário, você acabará adicionando-o duas vezes quando viewDidLoadfor chamado depois viewDidUnload(isso acontecerá após um aviso de memória). Isso não é necessário no iOS 6, onde viewDidUnloadestá obsoleto e não será chamado (porque as visualizações não são mais descarregadas automaticamente).

Na minha opinião, o código a seguir não faz sentido no ARC :

- (void)dealloc
{
      [[NSNotificationCenter defaultCenter] removeObserver:self];
      [super dealloc];
}

No iOS 6 , também não há sentido em remover observadores viewDidUnload, porque ele está obsoleto agora.

Para resumir, sempre faço isso em viewDidDisappear. Porém, também depende de seus requisitos, assim como disse @Dirk.

Acho que encontrei uma resposta confiável ! Tive de fazê-lo, pois as respostas acima são ambíguas e parecem contraditórias. Procurei livros de receitas e guias de programação.

Primeiro, o estilo de addObserver:em viewWillAppear:e removeObserver:emviewWillDisappear: não funciona para mim (eu testei) porque estou postando uma notificação em um controlador de visão filho para executar código no controlador de visão pai. Eu só usaria esse estilo se estivesse postando e ouvindo a notificação no mesmo controlador de visualização.

A resposta na qual mais confiarei, encontrei em iOS Programming: Big Nerd Ranch Guide 4. Eu confio nos caras do BNR porque eles têm centros de treinamento iOS e eles não estão apenas escrevendo outro livro de receitas. É provavelmente do seu interesse serem precisos.

BNR exemplo um: addObserver:em init:, removeObserver:emdealloc:

Exemplo dois de BNR: addObserver:em awakeFromNib:, removeObserver:emdealloc:

... ao remover o observador em dealloc:eles não usam[super dealloc];

Espero que isso ajude a próxima pessoa ...

Estou atualizando este post porque a Apple agora quase adotou completamente os Storyboards, então o mencionado acima pode não se aplicar a todas as situações. O importante (e a razão pela qual adicionei este post em primeiro lugar) é prestar atenção se você viewWillDisappear:for chamado. Não era para mim quando o aplicativo entrou em segundo plano.

A resposta aceita não é segura e pode causar vazamento de memória. Por favor, deixe o cancelamento de registro em dealloc, mas também cancele o registro em viewWillDisappear (isto é, claro, se você se registrar em viewWillAppear) .... ISSO É O QUE EU FIZ DE QUALQUER MANEIRA E FUNCIONOU BEM! :)

É importante notar também que viewWillDisappearé chamado também quando o controlador de visualização apresenta um novo UIView. Esse delegado simplesmente indica que a visualização principal do controlador de visualização não está visível na tela.

Nesse caso, desalocar a notificação em viewWillDisappearpode ser inconveniente se estivermos usando a notificação para permitir que o UIview se comunique com o controlador de visualização pai.

Como solução, geralmente removo o observador em um destes dois métodos:

- (void)viewWillDisappear:(BOOL)animated {
    NSLog(@"viewController will disappear");
    if ([self isBeingDismissed]) {
        NSLog(@"viewController is being dismissed");
        [[NSNotificationCenter defaultCenter] removeObserver:self name:@"actionCompleted" object:nil];
    }
}

-(void)dealloc {
    NSLog(@"viewController is being deallocated");
    [[NSNotificationCenter defaultCenter] removeObserver:self name:@"actionCompleted" object:nil];
}

Por razões semelhantes, quando eu emito a notificação pela primeira vez, preciso levar em consideração o fato de que sempre que uma exibição aparece acima do controlador, o viewWillAppearmétodo é disparado. Isso, por sua vez, irá gerar várias cópias da mesma notificação. Como não há uma maneira de verificar se uma notificação já está ativa, elimino o problema removendo a notificação antes de adicioná-la:

- (void)viewWillAppear:(BOOL)animated {
    NSLog(@"viewController will appear");
    // Add observers
    [[NSNotificationCenter defaultCenter] removeObserver:self name:@"imageGenerated" object:nil]; // This is added to avoid duplicate notifications when the view is presented again
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(receivedImageFromCameraOrPhotolibraryMethodOnListener:) name:@"actionCompleted" object:nil];

}

SWIFT 3

Existem dois casos de uso de notificações: - eles são necessários apenas quando o controlador de visualização está na tela; - eles são necessários sempre, mesmo se o usuário abrir outra tela ao longo da corrente.

Para o primeiro caso, o local correto para adicionar e remover o observador é:

/// Add observers
///
/// - Parameter animated: the animation flag
override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)
    NotificationCenter.default.addObserver(...)
}

/// Remove observers
///
/// - Parameter animated: the animation flag
override func viewWillDisappear(_ animated: Bool) {
    super.viewWillDisappear(animated)
    NotificationCenter.default.removeObserver(self)
}

para o segundo caso, a maneira correta é:

/// Add observers
override func viewDidLoad() {
    super.viewDidLoad()
    NotificationCenter.default.addObserver(...)
}

/// Remove observers
///
/// - Parameter animated: the animation flag
override func viewWillDisappear(_ animated: Bool) {
    super.viewWillDisappear(animated)
    if self.isBeingDismissed // remove only when view controller is removed disappear forever
    || !(self.navigationController?.viewControllers.contains(self) ?? true) {
        NotificationCenter.default.removeObserver(self)
    }
}

E nunca colocar removeObserverem deinit{ ... }- é um erro!

override func viewDidLoad() {   //add observer
  super.viewDidLoad()
  NotificationCenter.default.addObserver(self, selector:#selector(Yourclassname.method), name: NSNotification.Name(rawValue: "NotificationIdentifier"), object: nil)
}

override func viewWillDisappear(_ animated: Bool) {    //remove observer
    super.viewWillDisappear(true)
    NotificationCenter.default.removeObserver(self, name: NSNotification.Name(rawValue: "NotificationIdentifier"), object: nil)
}