Sans exceptions

Sans ProviderNotFoundException et évite d'oublier de gérer les états d'erreurs ou de chargement. Avec Riverpod, si le code compile, il marche.

Provider, sans ses limitations

Riverpod est inspiré de Provider mais résout des problèmes clés tels que: le support de plusieurs providers du même type; attendre les providers asynchrones; définir des providers n'importe où; ...

Indépendant de Flutter

Permet de créer/partager/tester des providers, sans dépendre de Flutter. Cela inclut être capable d'écouter un provider sans BuildContext.

Déclarez un état partagé de n'importe où

Plus besoin de sauter entre votre main.dart et vos fichiers d'UI.
Placez le code de votre état partagé où vous voulez, que ce soit à côté du Widget qui l'utilise ou dans un autre package, sans perdre en testabilité.

// A shared state that can be accessed by multiple
// objects at the same time
final countProvider = StateProvider((ref) => 0);

// Consumes the shared state and rebuild when it changes
class Title extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final count = ref.watch(countProvider);
    return Text('$count');
  }
}

Mise à jour automatique de l'état de l'application et l'UI, seulement quand nécessaire

Il n'est plus nécessaire de trier/filtrer nos listes dans la méthode build ou d'utiliser des mécaniques avancées de cache.

Grâce à Provider et aux "families", triez vos listes ou faites des requêtes HTTP seulement quand c'est vraiment nécessaire.

final todosProvider = StateProvider<List<Todo>>((ref) => []);
final filterProvider = StateProvider<Filter>((ref) => Filter.all);

final filteredTodosProvider = Provider<List<Todo>>((ref) {
  final todos = ref.watch(todosProvider);
  switch (ref.watch(filterProvider)) {
    case Filter.all:
      return todos;
    case Filter.completed:
      return todos.where((todo) => todo.completed).toList();
    case Filter.uncompleted:
      return todos.where((todo) => !todo.completed).toList();
  }
});

Lecture sécurisée des providers

Lire un provider ne causera pas d'exceptions. Si vous pouvez lire un provider, une valeur valide sera obtenue.

Cela s'applique aussi aux valeurs obtenues de manière asynchrone. Avec Riverpod, les états de chargement et d'erreur seront gérés de manière sécurisée.

final configurationsProvider = FutureProvider<Configuration>((ref) async {
  final uri = Uri.parse('configs.json');
  final rawJson = await File.fromUri(uri).readAsString();

  return Configuration.fromJson(json.decode(rawJson));
});

class Example extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final configs = ref.watch(configurationsProvider);

    // Use Riverpod's built-in support
    // for error/loading states using "when":
    return configs.when(
      loading: () => const CircularProgressIndicator(),
      error: (err, stack) => Text('Error $err'),
      data: (configs) => Text('data: ${configs.host}'),
    );
  }
}

Inspectez l'état de votre application avec le Devtool Flutter

Via Riverpod, votre état est visible par défaut dans l'outil de Flutter.
Qui plus est, un outil d'inspection et d'édition d'état complet est en développement.