Can we omit dispose() in ChangeNotifiers & ValueNotifiers in Flutter?

Question

In Flutter and Dart, if I mix-in a ChangeNotifier, or use ValueNotifier<T> for example (_counter = ValueNotifier<int>(0)) should I always dispose() it? I understand that it has a dispose() member, which clears the listeners list. But in most examples I've found on the web dispose() is not utilized. I think that in most (all?) practical cases, e.g., when ListenableBuilders are used, the listeners will clean up for themselves, i.e., remove their listeners during their dispose() (this should be the case with ListenableBuilder, unless I'm mistaken?), so to implement/call dispose() for notifiers is not needed?

I'm having a hard time drafting the scenario where ommitting dispose() (on the notifier part, i.e., in the class that extends/mixes-in ChangeNotifier or defines/exposes ValueNotifier<T> objects) would create a memory leak or any other problem. Could you please help me clarify whether my thinking is correct, in other words - can I safely ignore dispose()ing notifiers?

To clarify - I know that if something is disposable, it would make sense to dispose() it eventually by default. But in this particular case, I think "dangling listeners" should not be a problem, if the mechanism is not misused by the client. I.e., all clients should unsubscribe when they don't need the notifications anymore, and if the notifier goes out of the scope (= is disposed) before this happens, this indicates the problem with the client logic anyway, is it not? In other words, if not disposing the notifier creates a memory leak, that's because of the faulty clients first and foremost, is it not?

Answer 1

If disposing adds too much complexity, like extra classes or a stateful widget, you can skip it. Most states are lazy or global anyway. However, if you're already using provider with scopes or a stateful widget, disposing is better. It ensures the notifier isn't listened to and Flutter clears it from memory.

ValueNotifiers have a specific memory allocation removed upon disposal. Flutter also has garbage collectors! So if the class that hold your value notifier is destroyed, Flutter will eventually dispose it for you. Listeners are also just lightweight callbacks, unlike stream subscriptions.

So yeah, you can safely ignore them for the predictable cases you mentioned. But counting on it isn't scalable/testable for big projects.

Answer 2

While omitting dispose() might work in some cases, it's generally better to dispose of ChangeNotifiers and ValueNotifiers to ensure proper resource management, prevent potential memory leaks, and maintain clean code practices.

Answer 3

Hm, so you fully understand the purpose of dispose(). I assume that you wonder why the Garbage collector couldn't do its job well, and we should not do this manually.

• I think it should not be a problem if any listeners or clients do the cleanup from their sides. The garbage collector will do its job when there is any orphan object left.
• The reason why dispose exists is for developers to better manage the resources, the developer will know when the resource is no longer needed, and it should release the memory to keep it low. If you have a small app, then there would be no significant benefits, but what if your app has large number of objects are leaving to the GC. The memory will be taken for nothing, for resource-limited devices that could be a severe problem because it requires GC to run more frequently, and the swap memory gets involved. You don't want your app to be slow huh.
• I don't have issues with the ValueNotifier, but I had experienced some unwanted exceptions when some objects still referred to the disposed Bloc. Some alive timers were trying to add more events into the Bloc, because I forgot to cancel it after disposing the widget. I would say it's not easy to find out the problem if you didn't touch that code for long. So manually cleanup all obsoleted listeners and release the memory will help your brain in the future.

It's just my opinion, feel free to debate.