Compile safe

Keine ProviderNotFoundException mehr und kein Vergessen der Behandlungen von Ladezuständen. Durch die Benutzung von Riverpod, funktioniert ihr Code, wenn er erfolgreich compiliert.

Provider ohne Einschränkungen

Riverpod ist von Provider inspiriert, löst aber einige seiner Hauptprobleme, wie z.B. die Unterstützung mehrerer Provider desselben Typs, das Warten auf asynchrone Provider, das Hinzufügen von Providern von überall ...

Hängt nicht von Flutter ab

Erstellen/teilen/testen von Providern, ohne Abhängigkeit zu Flutter. Dazu dazu gehört auch die Möglichkeit, auf Provider ohne einen BuildContext zu hören.

Gemeinsamen Zustand von überall aus deklarieren

Sie müssen nicht mehr zwischen Ihrer main.dart und Ihrer UI Dateien hin- und herspringen.
Platzieren Sie den Code Ihres gemeinsamen Zustands dort, wo er hingehört, sei in einem separaten Paket oder direkt nehben dem Widget, dass ihn benötigt, ohne dass die Testbarkeit verloren geht.

// 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');
  }
}

Neuberechnung von Zuständen/Neuaufbau der Benutzeroberfläche nur bei Bedarf

Listen müssen nicht mehr in der build Methode sortiert/gefiltert werden oder auf erweiterte Cache-Mechanismen zurückgreifen.

Mit Provider und "families", sortieren deiner Liste oder HTTP Requests müssen nur noch gemacht werden, wenn du es wirklich brauchst.

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();
  }
});

Provider sicher lesen

Das Lesen eines Providers wird niemals zu einem bad state führen. Wenn der benötigte Code zum Auslesen eines Providers geschrieben werden kann, erhält man einen validen Wert.

Das gilt auch für asynchron geladene Werte. Im Gegensatz zu Providern, erlaubt Riverpod eine saubere Handhabung von Lade-/Fehlerfällen.

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}'),
    );
  }
}

Überprüfen Sie ihren Zustand im devtool

Durch die Verwendung von Riverpod, ist ihr Zustand direkt im Devtool von Flutter sichtbar.
Darüber hinaus ist ein vollwertiger State-Inspector in Arbeit.