State Management in Flutter nel 2026: Riverpod vs Bloc vs GetX - Guida Completa

La gestione dello stato rappresenta una delle decisioni architetturali piu critiche nello sviluppo di applicazioni Flutter. Nel 2026, tre soluzioni dominano l'ecosistema: Riverpod 3.0, Bloc 9.0 e GetX. Questa guida analizza ciascuna opzione con esempi concreti, metriche di performance e strategie di migrazione.

Riverpod 3.0: Sicurezza a Tempo di Compilazione e Auto-Retry

Riverpod 3.0 ha introdotto un cambiamento fondamentale nel modo in cui le applicazioni Flutter dichiarano e consumano lo stato. La generazione di codice basata su annotazioni rileva gli errori di dipendenza a tempo di compilazione anziche a runtime, eliminando un'intera classe di bug che in precedenza richiedevano test manuali.

Il meccanismo di auto-retry per i provider falliti gestisce gli errori di rete transitori senza intervento manuale. Quando il calcolo di un provider fallisce, Riverpod riprova automaticamente con un ritardo configurabile.

import 'package:riverpod_annotation/riverpod_annotation.dart';

part 'counter_provider.g.dart';

// Code generation ensures compile-time safety
@riverpod
class Counter extends _ {
  @override
  int build() => 0; // Initial state

  void increment() => state = state + 1;
  void decrement() => state = state - 1;
  void reset() => state = 0;
}

L'annotazione @riverpod genera tutto il boilerplate del provider. Errori di tipo, override mancanti e dipendenze circolari emergono durante la compilazione.

import 'package:riverpod_annotation/riverpod_annotation.dart';

part 'user_repository_provider.g.dart';

@riverpod
Future<User> currentUser(Ref ref) async {
  final authService = ref.watch(authServiceProvider);
  final userId = authService.currentUserId;

  // Auto-retry on network failure (Riverpod 3.0)
  final response = await ref.watch(
    httpClientProvider,
  ).get('/api/users/${userId}');

  return User.fromJson(response.data);
}

Riverpod 3.0 mette automaticamente in pausa i listener dei provider quando un widget esce dallo schermo, riducendo i calcoli non necessari e migliorando la durata della batteria sui dispositivi mobili.

Bloc 9.0: Architettura Event-Driven per Applicazioni Enterprise

Bloc 9.0 impone una separazione rigorosa tra eventi, stati e logica di business. Ogni cambiamento di stato corrisponde a un evento specifico, creando un audit trail richiesto dai settori regolamentati. I controlli di sicurezza mounted nella versione 9.0 impediscono l'esecuzione di callback su widget dismessi.

sealed class AuthenticationEvent {}

final class LoginRequested extends AuthenticationEvent {
  final String email;
  final String password;
  LoginRequested({required this.email, required this.password});
}

final class LogoutRequested extends AuthenticationEvent {}

final class SessionRestored extends AuthenticationEvent {
  final String token;
  SessionRestored({required this.token});
}

Le sealed class di Dart 3 garantiscono il pattern matching esaustivo sugli eventi. Il compilatore impone che ogni tipo di evento abbia un handler.

import 'package:flutter_bloc/flutter_bloc.dart';

class AuthenticationBloc
    extends Bloc<AuthenticationEvent, AuthenticationState> {
  final AuthRepository _authRepo;
  final TokenStorage _tokenStorage;

  AuthenticationBloc({
    required AuthRepository authRepo,
    required TokenStorage tokenStorage,
  })  : _authRepo = authRepo,
        _tokenStorage = tokenStorage,
        super(AuthenticationInitial()) {
    on<LoginRequested>(_onLoginRequested);
    on<LogoutRequested>(_onLogoutRequested);
    on<SessionRestored>(_onSessionRestored);
  }

  Future<void> _onLoginRequested(
    LoginRequested event,
    Emitter<AuthenticationState> emit,
  ) async {
    emit(AuthenticationLoading());
    try {
      final token = await _authRepo.login(
        email: event.email,
        password: event.password,
      );
      await _tokenStorage.save(token);
      emit(AuthenticationSuccess(token: token));
    } catch (e) {
      emit(AuthenticationFailure(message: e.toString()));
    }
  }

  Future<void> _onLogoutRequested(
    LogoutRequested event,
    Emitter<AuthenticationState> emit,
  ) async {
    await _tokenStorage.clear();
    emit(AuthenticationInitial());
  }

  Future<void> _onSessionRestored(
    SessionRestored event,
    Emitter<AuthenticationState> emit,
  ) async {
    emit(AuthenticationSuccess(token: event.token));
  }
}

Ogni event handler produce una transizione di stato chiara. Il middleware di logging puo registrare ogni evento per scopi di debugging o conformita.

Event Transformer di Bloc: Gestione di Input ad Alta Frequenza

Bloc fornisce event transformer integrati che risolvono problemi comuni di concorrenza. La ricerca durante la digitazione, i tap rapidi sui pulsanti e i flussi di dati in tempo reale beneficiano tutti dell'elaborazione dichiarativa degli eventi.

import 'package:bloc_concurrency/bloc_concurrency.dart';
import 'package:flutter_bloc/flutter_bloc.dart';

class SearchBloc extends Bloc<SearchEvent, SearchState> {
  final SearchRepository _repository;

  SearchBloc({required SearchRepository repository})
      : _repository = repository,
        super(SearchInitial()) {
    // restartable() cancels previous search on new input
    on<SearchQueryChanged>(
      _onQueryChanged,
      transformer: restartable(),
    );
    // droppable() ignores events while processing
    on<SearchResultSelected>(
      _onResultSelected,
      transformer: droppable(),
    );
  }

  Future<void> _onQueryChanged(
    SearchQueryChanged event,
    Emitter<SearchState> emit,
  ) async {
    if (event.query.length < 3) {
      emit(SearchInitial());
      return;
    }
    emit(SearchLoading());
    final results = await _repository.search(event.query);
    emit(SearchLoaded(results: results));
  }

  Future<void> _onResultSelected(
    SearchResultSelected event,
    Emitter<SearchState> emit,
  ) async {
    emit(SearchNavigating(result: event.result));
  }
}

Il transformer restartable() annulla qualsiasi ricerca in corso quando arriva un nuovo input, impedendo che risultati obsoleti sovrascrivano quelli aggiornati. Il transformer droppable() ignora i tap duplicati mentre una navigazione e in corso.

GetX: Debito Tecnico e Realta della Migrazione

GetX ha guadagnato popolarita grazie alla velocita di prototipazione rapida e al boilerplate minimo. Nel 2026, la libreria affronta una crisi di manutenzione: aggiornamenti sporadici, un collo di bottiglia legato a un singolo manutentore e incompatibilita crescenti con le versioni recenti dell'SDK Flutter. Le applicazioni in produzione che utilizzano GetX riscontrano problemi nel ciclo di vita dei controller e memory leak dovuti a singleton globali impliciti.

import 'package:get/get.dart';

// Global singleton - difficult to test and scope
class CounterController extends GetxController {
  final count = 0.obs; // Reactive observable

  void increment() => count.value++;
  void decrement() => count.value--;

  // Lifecycle hooks - disposal timing is unpredictable
  @override
  void onClose() {
    // Cleanup may not execute reliably
    super.onClose();
  }
}

// Usage in widget
class CounterPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    // Get.put creates a global singleton
    final controller = Get.put(CounterController());
    return Obx(() => Text('${controller.count}'));
  }
}

La chiamata Get.put() registra i controller come singleton globali. Nei flussi di navigazione complessi, i controller persistono oltre il loro scope previsto, consumando memoria. Le variabili reattive .obs aggirano il sistema standard di notifica dello stato di Flutter, rendendo l'integrazione con altri pacchetti inaffidabile.

Migrazione da GetX a Riverpod: Passo dopo Passo

Per i team che mantengono codebase GetX, la migrazione a Riverpod puo procedere in modo incrementale. Entrambe le librerie coesistono nello stesso progetto, permettendo la conversione schermo per schermo senza una riscrittura completa.

// Step 1: Replace GetX controller with Riverpod notifier
// Before (GetX)
class ProductController extends GetxController {
  final products = <Product>[].obs;
  final isLoading = false.obs;

  Future<void> loadProducts() async {
    isLoading.value = true;
    products.value = await ProductApi.fetchAll();
    isLoading.value = false;
  }
}

// After (Riverpod 3.0)
@riverpod
class ProductList extends _ {
  @override
  Future<List<Product>> build() async {
    // Auto-retry on failure, auto-pause when off-screen
    return ProductApi.fetchAll();
  }

  Future<void> refresh() async {
    ref.invalidateSelf();
  }
}

// Step 2: Replace widget bindings
// Before (GetX)
class ProductPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    final ctrl = Get.put(ProductController());
    return Obx(() {
      if (ctrl.isLoading.value) return CircularProgressIndicator();
      return ListView.builder(
        itemCount: ctrl.products.length,
        itemBuilder: (_, i) => ProductTile(ctrl.products[i]),
      );
    });
  }
}

// After (Riverpod 3.0)
class ProductPage extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final productsAsync = ref.watch(productListProvider);
    return productsAsync.when(
      loading: () => const CircularProgressIndicator(),
      error: (err, stack) => ErrorDisplay(error: err),
      data: (products) => ListView.builder(
        itemCount: products.length,
        itemBuilder: (_, i) => ProductTile(products[i]),
      ),
    );
  }
}

La versione Riverpod gestisce gli stati di loading, errore e dati esplicitamente tramite AsyncValue.when(). Nessun singleton globale, nessuna gestione manuale del ciclo di vita e dispose automatico quando il widget viene smontato.

Confronto delle Performance: Efficienza dei Rebuild

L'efficienza dei rebuild influisce direttamente sui frame rate. Ogni soluzione gestisce i rebuild dei widget in modo diverso, e la differenza diventa misurabile nelle liste con centinaia di elementi.

| Metrica | Riverpod 3.0 | Bloc 9.0 | GetX | |--------|-------------|----------|------| | Rebuild selettivo | select() filter | BlocSelector | .obs per campo | | Sicurezza compile-time | Completa (code gen) | Parziale (sealed classes) | Nessuna | | Auto-dispose | Integrato | Manuale via close() | Inaffidabile | | Pausa fuori schermo | Automatica (3.0) | Manuale | Non supportata | | Tracciabilita eventi | Provider observer | Log eventi completo | Nessuna | | Isolamento test | ProviderContainer.test() | EmittableStateStreamableSource | Richiede Get.testMode | | Impatto bundle size | ~45KB | ~38KB | ~120KB (incl. routing, DI, HTTP) |

Il metodo select() di Riverpod e il BlocSelector di Bloc consentono entrambi rebuild chirurgici, aggiornando solo il sottalbero di widget che dipende dai dati modificati. Il .obs di GetX raggiunge una granularita simile per campo, ma manca di verifica compile-time del grafo delle dipendenze.

Strategie di Testing nelle Diverse Soluzioni

La testabilita spesso determina quale soluzione scala con un team in crescita. Ogni libreria affronta il testing in modo diverso.

// Riverpod test - isolated container
import 'package:flutter_test/flutter_test.dart';
import 'package:riverpod/riverpod.dart';

void main() {
  test('Counter increments', () {
    final container = ProviderContainer.test();
    // Override dependencies for isolation
    final counter = container.read(counterProvider.notifier);

    expect(container.read(counterProvider), 0);
    counter.increment();
    expect(container.read(counterProvider), 1);
  });
}

// Bloc test - event-driven verification
import 'package:bloc_test/bloc_test.dart';
import 'package:flutter_test/flutter_test.dart';

void main() {
  blocTest<AuthenticationBloc, AuthenticationState>(
    'emits [loading, success] on valid login',
    build: () => AuthenticationBloc(
      authRepo: MockAuthRepo(),
      tokenStorage: MockTokenStorage(),
    ),
    act: (bloc) => bloc.add(
      LoginRequested(email: 'dev@test.com', password: 'secure123'),
    ),
    expect: () => [
      isA<AuthenticationLoading>(),
      isA<AuthenticationSuccess>(),
    ],
  );
}

Il ProviderContainer.test() di Riverpod crea un grafo di dipendenze isolato per test. L'helper blocTest di Bloc verifica le sequenze esatte di transizione di stato. Il testing di GetX richiede l'impostazione di Get.testMode = true e la gestione manuale del ciclo di vita dei controller, il che porta frequentemente a test instabili negli ambienti CI.

Matrice Decisionale: Scegliere la Soluzione Giusta

I vincoli del progetto determinano la scelta migliore. La dimensione del team, i requisiti normativi e la codebase esistente influenzano tutti la decisione.

Riverpod 3.0 e adatto quando il team apprezza la sicurezza compile-time, il progetto necessita di data fetching asincrono con recupero automatico degli errori, o la codebase parte da zero. La curva di apprendimento e moderata: gli sviluppatori familiari con Provider fanno una transizione naturale.

Bloc 9.0 e adatto quando il progetto opera in un settore regolamentato (fintech, sanita), il team necessita di tracciabilita completa degli eventi per l'auditing, o l'applicazione gestisce workflow concorrenti complessi come l'elaborazione dei pagamenti. Il costo del boilerplate si ripaga in manutenibilita su larga scala.

GetX e adatto solo quando si mantiene una codebase GetX esistente dove il costo della migrazione supera il budget disponibile. Avviare nuovi progetti con GetX nel 2026 introduce debito tecnico dal primo giorno. La documentazione ufficiale di Flutter non elenca GetX tra le soluzioni raccomandate.

Per una pratica approfondita sui pattern di state management in Flutter, il modulo fondamentali dello state management copre i concetti fondamentali testati nei colloqui. Il modulo sul pattern provider esplora le strategie di dependency injection applicabili a tutte e tre le soluzioni.

Conclusione

• Riverpod 3.0 offre sicurezza compile-time attraverso la generazione di codice, retry automatico per i provider falliti e supporto pause/resume che riduce il consumo di batteria sui dispositivi mobili
• Bloc 9.0 impone transizioni di stato event-driven con piena capacita di audit, rendendolo lo standard per le applicazioni enterprise nei settori regolamentati
• GetX affronta una crisi di manutenzione nel 2026 con aggiornamenti sporadici e crescenti incompatibilita SDK; i progetti GetX esistenti dovrebbero pianificare una migrazione incrementale a Riverpod
• La migrazione da GetX a Riverpod procede schermo per schermo senza richiedere una riscrittura completa, poiche entrambe le librerie coesistono nello stesso progetto
• L'isolamento dei test differisce significativamente: Riverpod usa ProviderContainer.test(), Bloc usa blocTest con verifica delle sequenze di eventi, e GetX richiede una configurazione fragile della modalita test globale
• La dimensione del bundle conta su mobile: Riverpod (~45KB) e Bloc (~38KB) distribuiscono pacchetti focalizzati, mentre GetX (~120KB) include funzionalita inutilizzate