using ref.keepAlive() vs @Riverpod(keepAlive: true)

[2kjm]

Hi everyone,

I have a question about using ref.keepAlive() versus the @Riverpod(keepAlive: true) annotation in Riverpod.

I'm wondering if these two approaches achieve the same effect. Specifically, are they functionally equivalent?

For example, consider the following implementation using ref.keepAlive():

class GuestRepository extends _$GuestRepository {
  @override
  Future<GuestMap?> build() async {
    ref.keepAlive();
    // Additional logic here
  }
}

And this implementation using the @Riverpod(keepAlive: true) annotation:

@Riverpod(keepAlive: true)
class GuestRepository extends _$GuestRepository {
  @override
  Future<GuestMap?> build() async {
    // Additional logic here
 }
}

[AhmedLSayed9]

Yes, they should achieve the same effect.

[dohyxx]

It's the same functionally, but isn't there a difference in memory? @AhmedLSayed9

[2kjm]

Yes. If we use ref.keepAlive() inside the build method it keeps a separate provider in memory. That means we can have more than one version of the same provider which could be listened to by two separate widgets or providers. One example is if we want a provider with two different family arguments to be kept alive.

if we use Riverpod(keepAlive: true) there would be only one version of that provider in memory. So all widgets and providers that watch this provider will always point to one unique provider.

[dohyxx]

Thank you @2kjm
I think using ref.keepAlive() to manage providers that need to maintain state is more memory efficient because it allows closing them individually,

Riverpod(keepAlive: true) does not disposed of the provider but only refreshes (invalidates) it instead. Am I wrong?

[rrousselGit]

@Riverpod(keepAlive: true) can be used by the linter to know if a provider is always kept alive.
But ref.keepAlive() can't

In terms of how they impact your app, both work the same. But one of them empowers riverpod_lint to tell you when you're doing something wrong.

Also, be careful with ref.keepAlive() + async*

async* implies an await null at its start.

If you write:

@riverpod
Stream<Model> example(ref) async* {
  ref.keepAlive();
}

That's like if you did:

@riverpod
Future<Model> example(ref) async {
  await null;
  ref.keepAlive();
}

So there's a small chance your provider gets disposed before ref.keepAlive is reached.