在Swift中解除分配

original title: "dealloc in Swift"


Translate

I would like to perform some cleanup at the end of a view controller's life, namely to remove an NSNotificationCenter notification. Implementing dealloc results in a Swift compiler error:

Cannot override 'dealloc' which has been marked unavailable

What is the preferred way to perform some cleanup at the end of an object's life in Swift?



我想在视图控制器寿命结束时执行一些清除操作,即删除NSNotificationCenter通知。实现dealloc会导致Swift编译器错误:无法...

这是翻译后的摘要,如果您需要查看完整的翻译,请单击“Translate”图标


所有的回答
  • Translate
    deinit {
        // perform the deinitialization
    }
    

    From the Swift Documentation:

    A deinitializer is called immediately before a class instance is deallocated. You write deinitializers with the deinit keyword, similar to how intializers are written with the init keyword. Deinitializers are only available on class types.

    Typically you don’t need to perform manual clean-up when your instances are deallocated. However, when you are working with your own resources, you might need to perform some additional clean-up yourself. For example, if you create a custom class to open a file and write some data to it, you might need to close the file before the class instance is deallocated.


  • Translate
    deinit {
        // perform the deinitialization
    }
    

    is the correct answer for Swift "dealloc".

    However, it is good to point out new in iOS 9 that NSNotificationCenter no longer needs to be cleaned up!

    https://developer.apple.com/library/content/releasenotes/Foundation/RN-FoundationOlderNotes/index.html#X10_11Notes

    NSNotificationCenter

    In OS X 10.11 and iOS 9.0 NSNotificationCenter and NSDistributedNotificationCenter will no longer send notifications to registered observers that may be deallocated. If the observer is able to be stored as a zeroing-weak reference the underlying storage will store the observer as a zeroing weak reference, alternatively if the object cannot be stored weakly (i.e. it has a custom retain/release mechanism that would prevent the runtime from being able to store the object weakly) it will store the object as a non-weak zeroing reference. This means that observers are not required to un-register in their deallocation method. The next notification that would be routed to that observer will detect the zeroed reference and automatically un-register the observer. If an object can be weakly referenced notifications will no longer be sent to the observer during deallocation; the previous behavior of receiving notifications during dealloc is still present in the case of non-weakly zeroing reference observers. Block based observers via the -[NSNotificationCenter addObserverForName:object:queue:usingBlock] method still need to be un-registered when no longer in use since the system still holds a strong reference to these observers. Removing observers (either weakly referenced or zeroing referenced) prematurely is still supported. CFNotificationCenterAddObserver does not conform to this behavior since the observer may not be an object.

    but note the points below about strong references, so you may have to worry about cleanup anyway...?


  • Translate

    https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Deinitialization.html

    Swift automatically deallocates your instances when they are no longer needed, to free up resources. Swift handles the memory management of instances through automatic reference counting (ARC), as described in Automatic Reference Counting. Typically you don’t need to perform manual clean-up when your instances are deallocated. However, when you are working with your own resources, you might need to perform some additional clean-up yourself. For example, if you create a custom class to open a file and write some data to it, you might need to close the file before the class instance is deallocated.

    Class definitions can have at most one deinitializer per class. The deinitializer does not take any parameters and is written without parentheses:

    deinit {
        // perform the deinitialization
    }
    

  • Translate

    removing observer is required before deallocation otherwise crash would happen. It can be done using

    deinit {
        // perform the deinitialization
        print("deinit")
    
        removeObserver(self, forKeyPath: kSelectedViewControllerKey, context: nil)
        removeObserver(self, forKeyPath: kSelectedIndexKey, context: nil)
    
    }
    

  • Translate

    Be careful when calling a method in other class from deinit it will probably end up in crash