La question "quelle librairie de state management choisir pour Flutter" revient dans presque toutes les revues d'architecture, et la réponse qui circule le plus souvent ("Bloc pour les gros projets, Provider pour les petits") est trop vague pour être utile. Les trois solutions résolvent le même problème de fond, à savoir propager un état et ses changements sans reconstruire tout l'arbre de widgets, mais avec des compromis très différents sur le boilerplate, la testabilité, et la facilité à onboarder une équipe. Le choix dépend moins de la taille du projet que de la discipline d'équipe qu'on peut imposer et de la complexité réelle des flux asynchrones à gérer.
Le problème commun : setState ne suffit plus
Dans un widget StatefulWidget isolé, setState reconstruit le widget local, c'est suffisant pour un compteur ou un champ de formulaire. Le problème apparaît quand un même état (l'utilisateur connecté, le panier, une liste filtrée) doit être lu et modifié depuis plusieurs écrans sans lien parent-enfant direct. Faire remonter l'état via des callbacks à travers cinq niveaux de widgets ("prop drilling") devient vite illisible, et dupliquer l'état dans chaque écran provoque des désynchronisations.
Les trois solutions règlent ce problème via InheritedWidget sous le capot (Provider et Riverpod l'exposent plus ou moins directement, Bloc s'appuie sur BlocProvider qui fait la même chose), mais avec des philosophies différentes sur la façon de modéliser le changement d'état.
Provider : le minimum viable, avec ses limites connues
Provider enveloppe InheritedWidget dans une API plus simple et reste la porte d'entrée la plus légère pour qui découvre le state management Flutter.
class CartModel extends ChangeNotifier {
final List<CartItem> _items = [];
List<CartItem> get items => List.unmodifiable(_items);
double get total => _items.fold(0, (sum, item) => sum + item.price * item.quantity);
void addItem(CartItem item) {
_items.add(item);
notifyListeners();
}
}
// main.dart
ChangeNotifierProvider(
create: (_) => CartModel(),
child: const MyApp(),
);
// dans un widget enfant, n'importe où dans l'arbre
final cart = context.watch<CartModel>();
Text('${cart.items.length} articles');
Les limites apparaissent sur des projets de taille moyenne : ChangeNotifier impose une classe mutable avec notifyListeners() appelé manuellement, ce qui rend facile d'oublier un cas et de se retrouver avec un écran qui ne se met pas à jour. La dépendance au BuildContext pour lire ou écrire l'état (context.read, context.watch) complique les tests unitaires purs (sans widget tree) et le découplage de la logique métier.
Riverpod : la même idée, sans dépendance au widget tree
Riverpod a été écrit par le même auteur que Provider précisément pour corriger ces limites. La différence structurelle principale est que les "providers" Riverpod existent indépendamment du BuildContext et sont déclarés comme des variables globales (mais testables et override-ables), ce qui rend la logique testable sans monter de widget.
// cart_provider.dart
class CartState {
final List<CartItem> items;
const CartState(this.items);
double get total => items.fold(0, (sum, item) => sum + item.price * item.quantity);
}
class CartNotifier extends Notifier<CartState> {
@override
CartState build() => const CartState([]);
void addItem(CartItem item) {
state = CartState([...state.items, item]);
}
}
final cartProvider = NotifierProvider<CartNotifier, CartState>(CartNotifier.new);
// dans un widget, avec Riverpod + flutter_hooks ou ConsumerWidget
class CartScreen extends ConsumerWidget {
@override
Widget build(BuildContext context, WidgetRef ref) {
final cart = ref.watch(cartProvider);
return Text('${cart.items.length} articles - ${cart.total} EUR');
}
}
Le vrai avantage pratique est la gestion native de l'asynchrone via FutureProvider et AsyncValue, qui encode explicitement les trois états (chargement, données, erreur) sans code répétitif :
final userProfileProvider = FutureProvider<UserProfile>((ref) async {
final api = ref.watch(apiClientProvider);
return api.fetchProfile();
});
// dans le widget
ref.watch(userProfileProvider).when(
data: (profile) => Text(profile.name),
loading: () => const CircularProgressIndicator(),
error: (err, stack) => Text('Erreur: $err'),
);
Le coût est une courbe d'apprentissage plus raide (comprendre les familles de providers, ref.watch vs ref.read vs ref.listen, l'invalidation et le autoDispose) et un outillage de génération de code (riverpod_generator) souvent utilisé en pratique pour réduire le boilerplate des annotations, ce qui ajoute une étape de build.
Bloc : la discipline architecturale, au prix du boilerplate
Bloc impose un pattern strict : chaque changement d'état est déclenché par un "event" explicite, traité par le bloc, qui émet un nouvel état. Cette discipline (inspirée des architectures Redux/Flux) rend le flux de données entièrement traçable et unidirectionnel, ce qui est précieux sur des équipes de plusieurs développeurs où on veut pouvoir relire n'importe quel changement d'état sans deviner d'où il vient.
// cart_event.dart
abstract class CartEvent {}
class AddItemEvent extends CartEvent {
final CartItem item;
AddItemEvent(this.item);
}
// cart_state.dart
abstract class CartState {}
class CartInitial extends CartState {}
class CartUpdated extends CartState {
final List<CartItem> items;
CartUpdated(this.items);
}
// cart_bloc.dart
class CartBloc extends Bloc<CartEvent, CartState> {
CartBloc() : super(CartInitial()) {
on<AddItemEvent>((event, emit) {
final current = state is CartUpdated ? (state as CartUpdated).items : <CartItem>[];
emit(CartUpdated([...current, event.item]));
});
}
}
// dans le widget
BlocBuilder<CartBloc, CartState>(
builder: (context, state) {
if (state is CartUpdated) {
return Text('${state.items.length} articles');
}
return const Text('Panier vide');
},
);
La testabilité est excellente nativement : le package bloc_test permet de tester une séquence exacte d'états émis en réponse à une séquence d'événements, sans monter le moindre widget. C'est un vrai atout pour une équipe qui veut imposer une couverture de tests stricte sur la logique métier. Le prix est un volume de fichiers et de classes bien supérieur à Provider ou Riverpod pour un cas d'usage équivalent, ce qui peut sembler disproportionné sur un écran simple comme un formulaire de connexion.
Le vrai critère de décision
Le choix ne devrait pas se faire sur "la taille du projet" en abstrait, mais sur trois questions concrètes :
- Combien de flux asynchrones concurrents faut-il gérer par écran ? Si la réponse est "beaucoup, avec dépendances entre eux" (un flux de recherche qui dépend d'un flux de filtres qui dépend de la géolocalisation), Riverpod gère nativement cette composition via
ref.watchentre providers, sans code de plomberie supplémentaire. - L'équipe a-t-elle besoin d'une structure imposée pour rester cohérente dans le temps ? Si l'équipe est grande, tourne, ou si le projet doit rester maintenable par des développeurs juniors qui rejoignent plus tard, la rigidité de Bloc (un seul endroit où chercher "comment cet état change") devient un atout plutôt qu'une contrainte.
- Quel est le coût réel de la migration si la solution initiale ne suffit plus ? Provider est souvent un bon point de départ sur un MVP, mais migrer vers Riverpod ou Bloc plus tard implique de retoucher chaque écran qui consomme l'état ; ce coût doit être budgété dès le départ si le projet a vocation à grossir.
Quand aucune des trois ne suffit
Sur des applications avec une logique métier offline-first complexe (synchronisation différée, résolution de conflits, cache local persistant), le state management seul (quel qu'il soit) ne résout pas le problème. Il faut alors une couche de persistance dédiée (Drift/SQLite, Isar) avec une logique de synchronisation explicite, et le choix entre Provider/Riverpod/Bloc ne sert plus qu'à exposer l'état déjà résolu par cette couche aux widgets, pas à porter la logique de synchronisation elle-même.
À retenir
Provider convient à un MVP ou une petite app sans flux asynchrones complexes ; Riverpod apporte la testabilité hors widget tree et une composition propre des dépendances asynchrones, au prix d'une courbe d'apprentissage réelle ; Bloc impose une discipline event/state qui paie sur une grande équipe mais alourdit un écran simple. Décider sur la base des flux asynchrones réels et de la discipline d'équipe nécessaire, pas sur une règle de taille de projet généralisée à l'excès.
