Ziel C: Wo kann der Beobachter für die NS-Benachrichtigung entfernt werden?

Ich habe eine objektive C-Klasse. Darin habe ich eine init-Methode erstellt und darin eine NSNotification eingerichtet

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

Wo stelle ich das [[NSNotificationCenter defaultCenter] removeObserver:self]in dieser Klasse ein? Ich weiß, dass ich es für a UIViewControllerin die viewDidUnloadMethode einfügen kann. Was muss also getan werden, wenn ich gerade eine objektive c-Klasse erstellt habe?

Die generische Antwort wäre "sobald Sie die Benachrichtigungen nicht mehr benötigen". Dies ist offensichtlich keine zufriedenstellende Antwort.

Ich würde empfehlen, dass Sie einen Anruf hinzufügen , [notificationCenter removeObserver: self]in Verfahren deallocdieser Klassen, die Sie als Beobachter verwenden möchten, da es die letzte Chance zu austragen Beobachter sauber ist. Dies schützt Sie jedoch nur vor Abstürzen, da das Benachrichtigungscenter tote Objekte benachrichtigt. Es kann Ihren Code nicht vor dem Empfang von Benachrichtigungen schützen, wenn sich Ihre Objekte noch nicht / nicht mehr in einem Zustand befinden, in dem sie die Benachrichtigung ordnungsgemäß verarbeiten können. Dafür ... Siehe oben.

Bearbeiten (da die Antwort mehr Kommentare zu zeichnen scheint, als ich gedacht hätte) Ich versuche hier nur zu sagen: Es ist wirklich schwierig, allgemeine Ratschläge zu geben, wann es am besten ist, den Beobachter aus dem Benachrichtigungscenter zu entfernen, da dies davon abhängt:

• Zu Ihrem Anwendungsfall (Welche Benachrichtigungen werden beobachtet? Wann werden sie gesendet?)
• Die Implementierung des Beobachters (Wann ist er bereit, Benachrichtigungen zu erhalten? Wann ist er nicht mehr bereit?)
• Die beabsichtigte Lebensdauer des Beobachters (Ist sie an ein anderes Objekt gebunden, z. B. eine Ansicht oder eine Ansichtssteuerung?)
• ...

Der beste allgemeine Rat, den ich finden kann: Zum Schutz Ihrer App. removeObserver:Tanzen Sie gegen mindestens einen möglichen Fehler, deallocda dies der letzte Punkt (im Leben des Objekts) ist, an dem Sie dies sauber tun können. Was dies nicht bedeutet ist: "Verschieben Sie die Entfernung dealloceinfach, bis sie aufgerufen wird, und alles wird in Ordnung sein". Entfernen Sie stattdessen den Beobachter , sobald das Objekt nicht mehr bereit (oder erforderlich) ist, Benachrichtigungen zu erhalten . Das ist genau der richtige Moment. Da ich die Antworten auf eine der oben genannten Fragen nicht kenne, kann ich leider nicht einmal erraten, wann dieser Moment sein würde.

Sie können removeObserver:ein Objekt immer mehrmals sicher sichern (und alle bis auf den ersten Anruf mit einem bestimmten Beobachter sind Nops). Also: Überlegen Sie dealloc, ob Sie es (erneut) tun möchten, um sicherzugehen, aber in erster Linie: Machen Sie es zum richtigen Zeitpunkt (der von Ihrem Anwendungsfall bestimmt wird).

Seit iOS 9 müssen keine Beobachter mehr entfernt werden.

In OS X 10.11 und iOS 9.0 senden NSNotificationCenter und NSDistributedNotificationCenter keine Benachrichtigungen mehr an registrierte Beobachter, die möglicherweise freigegeben werden.

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

Hinweis: Dies wurde getestet und funktioniert zu 100%

Schnell

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

Ziel c

In iOS 6.0 > versionist es besser, Beobachter zu entfernen, viewWillDisappearda die viewDidUnloadMethode veraltet ist.

 [[NSNotificationCenter defaultCenter] removeObserver:observerObjectHere];

Es ist um ein Vielfaches besser, remove observerwenn die Ansicht aus dem entfernt wurde 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];
    }
}

Wenn der Beobachter einem Ansichts-Controller hinzugefügt wird , empfehle ich dringend, ihn hinzuzufügen viewWillAppearund zu entfernen viewWillDisappear.

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

Im Allgemeinen habe ich es in die deallocMethode eingefügt.

Verwenden Sie schnell deinit, da kein Dealloc verfügbar ist:

deinit {
    ...
}

Schnelle Dokumentation:

Ein Deinitializer wird unmittelbar vor der Freigabe einer Klasseninstanz aufgerufen. Sie schreiben Deinitializer mit dem Schlüsselwort deinit, ähnlich wie Intializer mit dem Schlüsselwort init geschrieben werden. Deinitializer sind nur für Klassentypen verfügbar.

Normalerweise müssen Sie keine manuelle Bereinigung durchführen, wenn Ihre Instanzen freigegeben werden. Wenn Sie jedoch mit Ihren eigenen Ressourcen arbeiten, müssen Sie möglicherweise selbst eine zusätzliche Bereinigung durchführen. Wenn Sie beispielsweise eine benutzerdefinierte Klasse erstellen, um eine Datei zu öffnen und Daten in diese zu schreiben, müssen Sie die Datei möglicherweise schließen, bevor die Zuordnung der Klasseninstanz aufgehoben wird.

* Bearbeiten: Dieser Hinweis gilt für iOS <= 5 (auch dort sollten Sie hinzufügen viewWillAppearund entfernen viewWillDisappear- der Hinweis gilt jedoch, wenn Sie aus irgendeinem Grund den Beobachter hinzugefügt haben viewDidLoad).

Wenn Sie den Beobachter hinzugefügt haben viewDidLoad, sollten Sie ihn in beiden deallocund entfernen viewDidUnload. Andernfalls fügen Sie es zweimal hinzu, wenn viewDidLoades danach aufgerufen wird viewDidUnload(dies geschieht nach einer Speicherwarnung). Dies ist in iOS 6 nicht erforderlich, wo viewDidUnloades veraltet ist und nicht aufgerufen wird (da Ansichten nicht mehr automatisch entladen werden).

Meiner Meinung nach macht der folgende Code in ARC keinen Sinn :

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

In iOS 6 macht es auch keinen Sinn, Beobachter zu entfernen viewDidUnload, da dies jetzt veraltet ist.

Zusammenfassend mache ich es immer in viewDidDisappear. Es hängt jedoch auch von Ihren Anforderungen ab, genau wie @Dirk sagte.

Ich glaube ich habe eine gefunden verlässliche Antwort gefunden ! Ich musste, da die obigen Antworten mehrdeutig sind und widersprüchlich erscheinen. Ich habe Kochbücher und Programmierhandbücher durchgesehen.

Erstens der Stil von addObserver:in viewWillAppear:undremoveObserver:viewWillDisappear: funktioniert in für mich nicht (ich habe ihn getestet), da ich eine Benachrichtigung in einem untergeordneten Ansichtscontroller poste, um Code im übergeordneten Ansichtscontroller auszuführen. Ich würde diesen Stil nur verwenden, wenn ich die Benachrichtigung im selben View Controller posten und abhören würde.

Die Antwort, auf die ich mich am meisten verlassen werde, fand ich in der iOS-Programmierung: Big Nerd Ranch Guide 4th. Ich vertraue den BNR-Leuten, weil sie iOS-Schulungszentren haben und nicht nur ein weiteres Kochbuch schreiben. Es ist wahrscheinlich in ihrem besten Interesse, genau zu sein.

BNR Beispiel eins: addObserver:ininit: , removeObserver:indealloc:

BNR-Beispiel zwei: addObserver:inawakeFromNib: , removeObserver:indealloc:

… Beim Entfernen des Beobachters in dealloc: sie diese nicht[super dealloc];

Ich hoffe das hilft der nächsten Person…

Ich aktualisiere diesen Beitrag, da Apple jetzt fast vollständig auf Storyboards verzichtet hat, sodass die oben genannten möglicherweise nicht für alle Situationen gelten. Das Wichtigste (und der Grund, warum ich diesen Beitrag überhaupt hinzugefügt habe) ist, darauf zu achten, wenn Sie viewWillDisappear:angerufen werden. Es war nichts für mich, als die Anwendung in den Hintergrund trat.

Die akzeptierte Antwort ist nicht sicher und kann zu einem Speicherverlust führen. Bitte lassen Sie die Abmeldung im Dealloc, aber melden Sie sich auch in viewWillDisappear ab (das ist natürlich, wenn Sie sich in viewWillAppear registrieren). :) :)

Es ist wichtig zu beachten, dass dies auch viewWillDisappearaufgerufen wird, wenn der View Controller eine neue UIView präsentiert. Dieser Delegat gibt lediglich an, dass die Hauptansicht des View Controllers auf dem Display nicht sichtbar ist.

In diesem Fall kann die Freigabe der Benachrichtigung viewWillDisappearunpraktisch sein, wenn wir die Benachrichtigung verwenden, damit die UIview mit dem übergeordneten Ansichtscontroller kommunizieren kann.

Als Lösung entferne ich den Beobachter normalerweise mit einer dieser beiden Methoden:

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

Aus ähnlichen Gründen muss ich beim ersten Ausstellen der Benachrichtigung berücksichtigen, dass jedes Mal, wenn eine Ansicht mit über dem Controller viewWillAppearangezeigt wird, die Methode ausgelöst wird. Dies erzeugt wiederum mehrere Kopien derselben Benachrichtigung. Da es keine Möglichkeit gibt, zu überprüfen, ob eine Benachrichtigung bereits aktiv ist, kann ich das Problem vermeiden, indem ich die Benachrichtigung entferne, bevor ich sie hinzufüge:

- (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

Es gibt zwei Fälle, in denen Benachrichtigungen verwendet werden: - Sie werden nur benötigt, wenn der Ansichts-Controller auf dem Bildschirm angezeigt wird. - Sie werden immer benötigt, auch wenn der Benutzer einen anderen Bildschirm über Strom geöffnet hat.

Für den ersten Fall ist der richtige Ort zum Hinzufügen und Entfernen von Beobachtern:

/// 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)
}

für den zweiten Fall ist der richtige Weg:

/// 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)
    }
}

Und nie setzen removeObserverin deinit{ ... }- es ist ein Fehler!

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