Is watching a changeNotifier an anti-pattern?

[oodavid]

I have some legacy provider code that uses ChangeNotifierProvider.

Is it reasonable to replace:

return ChangeNotifierProvider<SomeChangeNotifier>.value(
  value: someChangeNotifier,
  builder: (context, child) {
    final someChangeNotifier = Provider.of<SomeChangeNotifier>(context);
    return Whatever(someChangeNotifier);
  },
);

With the following?:

ref.watch(ChangeNotifierProvider((ref) => someChangeNotifier));
return Whatever(someChangeNotifier);

Expanded example

import 'package:provider/provider.dart';

class SomeWidget extends StatelessWidget {
  const SomeWidget({
    Key? key,
    required this.someChangeNotifier,
  }) : super(key: key);

  final SomeChangeNotifier someChangeNotifier;

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    return ChangeNotifierProvider<SomeChangeNotifier>.value(
      value: someChangeNotifier,
      builder: (context, child) {
        final someChangeNotifier = Provider.of<SomeChangeNotifier>(context);
        return Whatever(someChangeNotifier);
      },
    );
  }
}

import 'package:flutter_riverpod/flutter_riverpod.dart';

class FieldInput extends ConsumerWidget {
  const FieldInput({
    Key? key,
    required this.someChangeNotifier,
  }) : super(key: key);

  final SomeChangeNotifier someChangeNotifier;

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    ref.watch(ChangeNotifierProvider((ref) => someChangeNotifier));
    return Whatever(someChangeNotifier);
  }
}

[rrousselGit]

ref.watch(ChangeNotifierProvider((ref) => someChangeNotifier));

That line is definitely a no-go

You need to extract the ChangeNotifierProvider and declare it globally like you're expected to in Riverpod

If you can't (such as if your ChangeNotifier is a parameter of the widget), then maybe you want to use flutter_hooks instead.

You can write:

HookBuilder(
  builder: (context, child) {
    useListenable(someChangeNotifier);
    return Whatever(someChangeNotifier);
  }
)

[oodavid]

Oddly, this line appears to work as expected

ref.watch(ChangeNotifierProvider((ref) => someChangeNotifier));

I'll rewrite to use flutter_hooks as you suggest. Time to go forth an learn!

[oodavid]

...well, that was straightforward - thanks Remi

[rrousselGit]

Your line "works" in terms of rebuild. But it's inefficient and has a memory leak

Hooks are the expected solution 😊

[mark8044]

By the same token, I'm using the following pattern all over my app with great success, but along the same lines, is this ok? I know the data stays forever, unless I use autoDispose

main.dart

final mentionHelperProvider = ChangeNotifierProvider<MentionHelper>((ref) {
  return MentionHelper();
});

mention helper.dart

class MentionHelper with ChangeNotifier
{

  String _name = '';
  bool _iscurrentlylistening = false;
  List _results = [];
  String _insertvalue = '';
  int _cursorstartposition = 0;

  String get name => _name;
  bool get iscurrentlylistening => _iscurrentlylistening;
  List get results => _results;
  String get insertvalue => _insertvalue;
  int get cursorstartposition => _cursorstartposition;


  void initialValues()
  {
    _name = '';
    _results = [];
    _iscurrentlylistening = false;
    _insertvalue = '';
    _cursorstartposition = 0;
    notifyListeners();
  }


  Future<void> addToName(_newvalue)
  async {
    _name = _name+_newvalue;
    _results = await mentionFinder(_name);
    notifyListeners();
  }

  void setInsertValue(_newval)
  {
    _insertvalue = _newval;
    notifyListeners();
  }

}

elsewhere in app, it is used as:

ref.read(mentionHelperProvider). addToName('t');

and in build method as:

final myValue = ref.watch(mentionHelperProvider). name;

@rrousselGit

I always wondered two things:

1. Is this acceptable usage, especially since the official docs seem to frown on use of ChangeNotifierProvider
2. The data stays forever, unless I use autoDispose. Would this theoretically eventually lead to some kind of crash when the memory gets full? or does garbage collection eventually clear the data out