Correct way to read a autodispose AsyncNotifierProvider future

[dvaruas]

As part of this discussion thread #3600 @rrousselGit mentioned - "More specifically, "read" is discouraged on autoDispose providers.". I looked at the officical riverpod documentations and did not find anything like this mentioned. Can someone point out the relevant documentation section to me?

Secondly, if ref.read is discouraged, then should we use ref.watch instead? This goes against the info point mentioned in this document - https://riverpod.dev/docs/essentials/side_effects. Also since my callback is passed somewhere as a class member variable, the provider is never diisposed. I would prefer using ref.read instead.

And finally, it would be really helpful if someone can help me out with creating an extension similar to readFuture from the discussion, for an AsyncNotifier. I have something like below, but I am not satisfied with it specially since I have so many linter rule ignores.

extension WidgetRefExtensions on WidgetRef {
  Future<T> readAutoDisposeAsyncNotifierValue<
      // ignore: invalid_use_of_internal_member
      U extends BuildlessAutoDisposeAsyncNotifier<T>,
      T>(
    // ignore: invalid_use_of_internal_member
    AutoDisposeAsyncNotifierProviderImpl<U, T> provider,
  ) async {
    final sub = listenManual(
      provider,
      (_, __) {},
      fireImmediately: true,
    );
    return read(provider.future).whenComplete(sub.close);
  }
}

[HasanAlqaisi]

When reading the documentation, you'll notice that ref.read is generally discouraged, except in specific scenarios. The official docs state:

Using ref.read should be avoided as much as possible because it is not reactive.

It exists for cases where using watch or listen would cause issues. If you can, it is almost always better to use watch/listen, especially watch.

Regarding your second point — ref.read is actually the recommended approach inside callbacks like onPressed. From the same documentation page:

The watch method should not be called asynchronously, like inside an onPressed of an ElevatedButton. Nor should it be used inside initState and other State life-cycles.

In those cases, consider using ref.read instead.

And for the extension, I think we can do something like:

extension WidgetRefX on WidgetRef {
  Future<T> readAutoDisposeAsyncNotifierValue<T>(
    AutoDisposeAsyncNotifierProvider<AutoDisposeAsyncNotifier<T>, T> provider,
  ) async {
    final sub = listenManual(provider, (_, __) {}, fireImmediately: true);
    return read(provider.future).whenComplete(sub.close);
  }
}

[dvaruas]

Hi @HasanAlqaisi , thank you for your response.

When reading the docs that's the general impression I got as well - to favour watch unless using in async callbacks. Since as the linked discussion points out that there is no guarantee that when using ref.read(someProvider.future) the future might not be done, I was not sure what is the recommended approach. This is not evident at all from the docs and would be nice to have some clarity there.

Regarding your code-snippet, unfortunately that does not work due to type-mismatches. For example for a setup like this -

class Data {}

@riverpod
class Abc extends _$Abc {
   @override
   Future<Data> build({required int a}) => Future.value(Data());
}

ref.readAutoDisposeAsyncNotifierValue(abcProvider(a: 1) // this won't work due to type-mismatch