# Flutter State Management: Riverpod vs BLoC - Vollständiger Vergleichsleitfaden

> Detaillierter Vergleich zwischen Riverpod und BLoC für das State Management in Flutter. Architektur, Leistung, Testbarkeit und Anwendungsfälle für die richtige Wahl.

- Published: 2026-02-14
- Updated: 2026-04-28
- Author: SharpSkill
- Tags: flutter, riverpod, bloc, state management, dart
- Reading time: 12 min

---

State Management stellt eine zentrale Herausforderung in der Flutter-Entwicklung dar. Riverpod und BLoC dominieren das Ökosystem und bieten jeweils eine eigenständige Philosophie. Dieser Leitfaden vergleicht beide Lösungen anhand konkreter Implementierungen, um die Auswahl auf Basis der Projektanforderungen zu erleichtern.

> **Voraussetzungen**
>
> Dieser Leitfaden setzt Vertrautheit mit Flutter und den Grundlagen des State Managements voraus. Die Beispiele verwenden Riverpod 2.x und flutter_bloc 8.x, die aktuell stabilen Versionen.

## Kernphilosophien beider Ansätze

Riverpod und BLoC lösen dasselbe Problem mit gegensätzlichen Paradigmen. Das Verständnis dieser konzeptionellen Unterschiede ermöglicht die Wahl des richtigen Werkzeugs für jeden Kontext.

**Riverpod** verfolgt einen deklarativen und reaktiven Ansatz. Provider definieren Datenquellen, die Widgets beobachten. Das Framework verwaltet automatisch Lebenszyklus, Caching und Abhängigkeiten zwischen Providern.

**BLoC** (Business Logic Component) erzwingt eine strikte ereignisorientierte Architektur. Komponenten emittieren Events, der Bloc verarbeitet sie und produziert neue States. Diese explizite Trennung erleichtert die Nachverfolgung des Datenflusses.

```dart
// riverpod_philosophy.dart
// Riverpod: simple declaration, framework handles the rest
final counterProvider = StateProvider<int>((ref) => 0);

// Usage in a widget
class CounterWidget extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    // Reactive read: automatic rebuild if value changes
    final count = ref.watch(counterProvider);
    return Text('$count');
  }
}
```

```dart
// bloc_philosophy.dart
// BLoC: explicit events/states separation
abstract class CounterEvent {}
class IncrementPressed extends CounterEvent {}

class CounterBloc extends Bloc<CounterEvent, int> {
  CounterBloc() : super(0) {
    // Each event has its dedicated handler
    on<IncrementPressed>((event, emit) => emit(state + 1));
  }
}

// Usage in a widget
class CounterWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return BlocBuilder<CounterBloc, int>(
      builder: (context, count) => Text('$count'),
    );
  }
}
```

Die Wahl zwischen diesen Ansätzen hängt von den Vorlieben des Teams und den Projektbeschränkungen ab.

## Initiale Konfiguration

Die initiale Konfiguration zeigt ergonomische Unterschiede zwischen beiden Lösungen. Riverpod priorisiert Einfachheit, BLoC bietet mehr Struktur.

### Installation von Riverpod

Riverpod benötigt ein einziges Paket und einen Wrapper an der Anwendungswurzel. Optionale Codegenerierung verbessert die Produktivität.

```dart
// main.dart
// Riverpod configuration: single wrapper at root
import 'package:flutter_riverpod/flutter_riverpod.dart';

void main() {
  runApp(
    // ProviderScope wraps the entire application
    const ProviderScope(
      child: MyApp(),
    ),
  );
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: HomeScreen(),
    );
  }
}
```

### Installation von BLoC

BLoC benötigt mehrere Pakete und eine umfangreichere Konfiguration mit BlocProvidern für jeden verwendeten Bloc.

```dart
// main.dart
// BLoC configuration: explicit providers for each Bloc
import 'package:flutter_bloc/flutter_bloc.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    // MultiBlocProvider for multiple Blocs
    return MultiBlocProvider(
      providers: [
        BlocProvider(create: (_) => AuthBloc()),
        BlocProvider(create: (_) => ThemeBloc()),
      ],
      child: MaterialApp(
        home: HomeScreen(),
      ),
    );
  }
}
```

Die BLoC-Konfiguration erfordert mehr Initialcode, macht Abhängigkeiten aber von Anfang an explizit.

## Einfaches State Management: Counter und Toggles

Einfache Fälle illustrieren die alltägliche Ergonomie jeder Lösung. Riverpod glänzt durch Prägnanz, BLoC behält seine ereignisorientierte Struktur bei.

### Counter mit Riverpod

```dart
// counter_riverpod.dart
// StateProvider: simple state without complex logic
final counterProvider = StateProvider<int>((ref) => 0);

class CounterScreen extends ConsumerWidget {
  const CounterScreen({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    // watch for reactive value
    final count = ref.watch(counterProvider);

    return Scaffold(
      body: Center(child: Text('Count: $count')),
      floatingActionButton: FloatingActionButton(
        // read for actions (no rebuild)
        onPressed: () => ref.read(counterProvider.notifier).state++,
        child: const Icon(Icons.add),
      ),
    );
  }
}
```

### Counter mit BLoC

```dart
// counter_bloc.dart
// Typed events for each possible action
sealed class CounterEvent {}
class CounterIncremented extends CounterEvent {}
class CounterDecremented extends CounterEvent {}
class CounterReset extends CounterEvent {}

// Bloc with handlers for each event
class CounterBloc extends Bloc<CounterEvent, int> {
  CounterBloc() : super(0) {
    on<CounterIncremented>((event, emit) => emit(state + 1));
    on<CounterDecremented>((event, emit) => emit(state - 1));
    on<CounterReset>((event, emit) => emit(0));
  }
}

class CounterScreen extends StatelessWidget {
  const CounterScreen({super.key});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Center(
        child: BlocBuilder<CounterBloc, int>(
          builder: (context, count) => Text('Count: $count'),
        ),
      ),
      floatingActionButton: FloatingActionButton(
        // Event dispatch to modify state
        onPressed: () => context.read<CounterBloc>().add(CounterIncremented()),
        child: const Icon(Icons.add),
      ),
    );
  }
}
```

Für einfache Fälle reduziert Riverpod den Boilerplate erheblich. BLoC wird relevant, sobald die Logik komplexer wird.

> **StateProvider vs StateNotifierProvider**
>
> StateProvider eignet sich für einfache primitive Werte. Für komplexe Objekte oder Geschäftslogik bieten StateNotifierProvider oder NotifierProvider mehr Kontrolle.

## Asynchrones State Management: API-Aufrufe

Asynchrone Operationen offenbaren die Stärke jeder Lösung. Die Verwaltung von Loading-, Error- und Data-States stellt eine wesentliche Herausforderung dar.

### Asynchrone Daten mit Riverpod

```dart
// async_riverpod.dart
// FutureProvider: automatic loading/error/data management
final usersProvider = FutureProvider.autoDispose<List<User>>((ref) async {
  final repository = ref.watch(userRepositoryProvider);
  // autoDispose releases resources when provider is no longer used
  return repository.fetchUsers();
});

class UsersScreen extends ConsumerWidget {
  const UsersScreen({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final usersAsync = ref.watch(usersProvider);

    // when handles all 3 possible states
    return usersAsync.when(
      loading: () => const Center(child: CircularProgressIndicator()),
      error: (error, stack) => Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Text('Error: $error'),
            ElevatedButton(
              // invalidate forces reload
              onPressed: () => ref.invalidate(usersProvider),
              child: const Text('Retry'),
            ),
          ],
        ),
      ),
      data: (users) => ListView.builder(
        itemCount: users.length,
        itemBuilder: (context, index) => UserTile(user: users[index]),
      ),
    );
  }
}
```

### Asynchrone Daten mit BLoC

```dart
// async_bloc.dart
// Explicit states for each loading phase
sealed class UsersState {}
class UsersInitial extends UsersState {}
class UsersLoading extends UsersState {}
class UsersLoaded extends UsersState {
  final List<User> users;
  UsersLoaded(this.users);
}
class UsersError extends UsersState {
  final String message;
  UsersError(this.message);
}

// Events to trigger actions
sealed class UsersEvent {}
class UsersFetchRequested extends UsersEvent {}
class UsersRefreshRequested extends UsersEvent {}

class UsersBloc extends Bloc<UsersEvent, UsersState> {
  final UserRepository _repository;

  UsersBloc(this._repository) : super(UsersInitial()) {
    on<UsersFetchRequested>(_onFetchRequested);
    on<UsersRefreshRequested>(_onRefreshRequested);
  }

  Future<void> _onFetchRequested(
    UsersFetchRequested event,
    Emitter<UsersState> emit,
  ) async {
    emit(UsersLoading());
    try {
      final users = await _repository.fetchUsers();
      emit(UsersLoaded(users));
    } catch (e) {
      emit(UsersError(e.toString()));
    }
  }

  Future<void> _onRefreshRequested(
    UsersRefreshRequested event,
    Emitter<UsersState> emit,
  ) async {
    // Keep current state during refresh
    final currentState = state;
    try {
      final users = await _repository.fetchUsers();
      emit(UsersLoaded(users));
    } catch (e) {
      // Restore previous state on error
      if (currentState is UsersLoaded) {
        emit(currentState);
      } else {
        emit(UsersError(e.toString()));
      }
    }
  }
}
```

```dart
// users_screen_bloc.dart
// Widget with pattern matching on states
class UsersScreen extends StatelessWidget {
  const UsersScreen({super.key});

  @override
  Widget build(BuildContext context) {
    return BlocBuilder<UsersBloc, UsersState>(
      builder: (context, state) {
        return switch (state) {
          UsersInitial() => const Center(
              child: ElevatedButton(
                onPressed: _fetchUsers,
                child: Text('Load'),
              ),
            ),
          UsersLoading() => const Center(child: CircularProgressIndicator()),
          UsersError(:final message) => Center(
              child: Column(
                mainAxisAlignment: MainAxisAlignment.center,
                children: [
                  Text('Error: $message'),
                  ElevatedButton(
                    onPressed: () => context
                        .read<UsersBloc>()
                        .add(UsersFetchRequested()),
                    child: const Text('Retry'),
                  ),
                ],
              ),
            ),
          UsersLoaded(:final users) => ListView.builder(
              itemCount: users.length,
              itemBuilder: (context, index) => UserTile(user: users[index]),
            ),
        };
      },
    );
  }

  void _fetchUsers(BuildContext context) {
    context.read<UsersBloc>().add(UsersFetchRequested());
  }
}
```

BLoC bietet granulare Kontrolle über jeden State-Übergang. Riverpod automatisiert mehr über AsyncValue.

## State-Abhängigkeiten: Komposition und Injektion

Reale Anwendungen beinhalten voneinander abhängige States. Die Verwaltung dieser Abhängigkeiten unterscheidet beide Ansätze deutlich.

### Komposition mit Riverpod

```dart
// composition_riverpod.dart
// Base provider: configuration
final apiClientProvider = Provider<ApiClient>((ref) {
  final baseUrl = ref.watch(environmentProvider).apiUrl;
  return ApiClient(baseUrl: baseUrl);
});

// Dependent provider: repository
final productRepositoryProvider = Provider<ProductRepository>((ref) {
  // Automatic client injection
  final client = ref.watch(apiClientProvider);
  return ProductRepository(client);
});

// Provider with parameter: product by ID
final productProvider = FutureProvider.autoDispose.family<Product, String>(
  (ref, productId) async {
    final repository = ref.watch(productRepositoryProvider);
    return repository.getProduct(productId);
  },
);

// Derived provider: filtered products
final filteredProductsProvider = Provider<List<Product>>((ref) {
  final products = ref.watch(productsProvider).valueOrNull ?? [];
  final filter = ref.watch(productFilterProvider);

  return products.where((p) => p.category == filter.category).toList();
});

// Usage with parameter
class ProductDetailScreen extends ConsumerWidget {
  final String productId;

  const ProductDetailScreen({super.key, required this.productId});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    // family allows passing parameters
    final productAsync = ref.watch(productProvider(productId));

    return productAsync.when(
      loading: () => const ProductSkeleton(),
      error: (e, _) => ErrorWidget(error: e),
      data: (product) => ProductDetails(product: product),
    );
  }
}
```

### Komposition mit BLoC

```dart
// composition_bloc.dart
// Repository injected into the Bloc
class ProductBloc extends Bloc<ProductEvent, ProductState> {
  final ProductRepository _repository;
  final CartBloc _cartBloc;
  late final StreamSubscription _cartSubscription;

  ProductBloc({
    required ProductRepository repository,
    required CartBloc cartBloc,
  })  : _repository = repository,
        _cartBloc = cartBloc,
        super(ProductInitial()) {
    on<ProductFetchRequested>(_onFetchRequested);
    on<ProductAddedToCart>(_onAddedToCart);

    // Listen to cart changes
    _cartSubscription = _cartBloc.stream.listen((cartState) {
      // React to cart changes
      if (cartState is CartUpdated) {
        add(ProductCartSyncRequested(cartState.items));
      }
    });
  }

  Future<void> _onFetchRequested(
    ProductFetchRequested event,
    Emitter<ProductState> emit,
  ) async {
    emit(ProductLoading());
    try {
      final product = await _repository.getProduct(event.productId);
      // Check if product is in cart
      final isInCart = _cartBloc.state.contains(product.id);
      emit(ProductLoaded(product, isInCart: isInCart));
    } catch (e) {
      emit(ProductError(e.toString()));
    }
  }

  @override
  Future<void> close() {
    _cartSubscription.cancel();
    return super.close();
  }
}

// Configuration with dependency injection
class ProductsPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return BlocProvider(
      create: (context) => ProductBloc(
        repository: context.read<ProductRepository>(),
        cartBloc: context.read<CartBloc>(),
      )..add(ProductFetchRequested()),
      child: const ProductsView(),
    );
  }
}
```

Riverpod verwaltet Abhängigkeiten deklarativ. BLoC erfordert manuelle Verwaltung der Subscriptions zwischen Blocs.

## Testbarkeit und Mocking

Testen stellt ein entscheidendes Kriterium für professionelle Projekte dar. Beide Lösungen glänzen in diesem Bereich mit unterschiedlichen Ansätzen.

### Tests mit Riverpod

```dart
// test_riverpod.dart
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:mocktail/mocktail.dart';

class MockUserRepository extends Mock implements UserRepository {}

void main() {
  group('UserProvider Tests', () {
    late MockUserRepository mockRepository;
    late ProviderContainer container;

    setUp(() {
      mockRepository = MockUserRepository();
      // Isolated container with override
      container = ProviderContainer(
        overrides: [
          userRepositoryProvider.overrideWithValue(mockRepository),
        ],
      );
    });

    tearDown(() => container.dispose());

    test('returns users from repository', () async {
      // Arrange
      final expectedUsers = [User(id: '1', name: 'Test')];
      when(() => mockRepository.fetchUsers())
          .thenAnswer((_) async => expectedUsers);

      // Act
      final users = await container.read(usersProvider.future);

      // Assert
      expect(users, expectedUsers);
      verify(() => mockRepository.fetchUsers()).called(1);
    });

    test('handles repository errors', () async {
      when(() => mockRepository.fetchUsers())
          .thenThrow(Exception('Network error'));

      expect(
        () => container.read(usersProvider.future),
        throwsException,
      );
    });
  });
}
```

### Tests mit BLoC

```dart
// test_bloc.dart
import 'package:bloc_test/bloc_test.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:mocktail/mocktail.dart';

class MockUserRepository extends Mock implements UserRepository {}

void main() {
  group('UsersBloc Tests', () {
    late MockUserRepository mockRepository;

    setUp(() {
      mockRepository = MockUserRepository();
    });

    // blocTest simplifies state sequence testing
    blocTest<UsersBloc, UsersState>(
      'emits [Loading, Loaded] when fetch succeeds',
      build: () {
        when(() => mockRepository.fetchUsers())
            .thenAnswer((_) async => [User(id: '1', name: 'Test')]);
        return UsersBloc(mockRepository);
      },
      act: (bloc) => bloc.add(UsersFetchRequested()),
      expect: () => [
        isA<UsersLoading>(),
        isA<UsersLoaded>().having(
          (s) => s.users.length,
          'users count',
          1,
        ),
      ],
    );

    blocTest<UsersBloc, UsersState>(
      'emits [Loading, Error] when fetch fails',
      build: () {
        when(() => mockRepository.fetchUsers())
            .thenThrow(Exception('Network error'));
        return UsersBloc(mockRepository);
      },
      act: (bloc) => bloc.add(UsersFetchRequested()),
      expect: () => [
        isA<UsersLoading>(),
        isA<UsersError>(),
      ],
    );
  });
}
```

Das Paket `bloc_test` bietet eine dedizierte Syntax zum Testen von State-Sequenzen. Riverpod nutzt Standard-Test-Patterns von Flutter.

> **Testabdeckung**
>
> Nur die Standardfälle zu testen reicht nicht aus. Tests müssen Netzwerkfehler, Timeouts, Edge-Case-States und unerwartete State-Übergänge abdecken.

## Leistung und Rebuild-Optimierung

Die Leistung wirkt sich direkt auf die Nutzererfahrung aus. Beide Lösungen bieten unterschiedliche Optimierungsmechanismen.

### Optimierung mit Riverpod

```dart
// perf_riverpod.dart
// select to rebuild only if targeted value changes
class UserNameWidget extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    // Rebuilds only if user.name changes
    final name = ref.watch(userProvider.select((user) => user.name));
    return Text(name);
  }
}

// Provider with automatic caching
final expensiveComputationProvider = Provider<ExpensiveResult>((ref) {
  final input = ref.watch(inputProvider);
  // Computation automatically cached
  return performExpensiveComputation(input);
});

// autoDispose to release unused resources
final searchResultsProvider = FutureProvider.autoDispose
    .family<List<Product>, String>((ref, query) async {
  // Temporary keepAlive during typing
  final link = ref.keepAlive();

  // Timer to release after inactivity
  final timer = Timer(const Duration(seconds: 30), link.close);
  ref.onDispose(timer.cancel);

  return searchProducts(query);
});
```

### Optimierung mit BLoC

```dart
// perf_bloc.dart
// buildWhen limits rebuilds conditionally
class UserNameWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return BlocBuilder<UserBloc, UserState>(
      // Rebuilds only if name changes
      buildWhen: (previous, current) {
        if (previous is UserLoaded && current is UserLoaded) {
          return previous.user.name != current.user.name;
        }
        return true;
      },
      builder: (context, state) {
        if (state is UserLoaded) {
          return Text(state.user.name);
        }
        return const SizedBox.shrink();
      },
    );
  }
}

// BlocSelector to extract a specific value
class UserAvatarWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return BlocSelector<UserBloc, UserState, String?>(
      // Select only the avatar URL
      selector: (state) => state is UserLoaded ? state.user.avatarUrl : null,
      builder: (context, avatarUrl) {
        if (avatarUrl == null) return const DefaultAvatar();
        return NetworkImage(avatarUrl);
      },
    );
  }
}
```

Beide Lösungen bieten granulare Optimierungen. Riverpod mit `select`, BLoC mit `buildWhen` und `BlocSelector`.

## Praktischer Anwendungsfall: Vollständige Authentifizierung

Ein Authentifizierungssystem veranschaulicht reale Patterns für jede Lösung. Dieser Fall kombiniert persistenten State, API-Aufrufe und Navigation.

### Authentifizierung mit Riverpod

```dart
// auth_riverpod.dart
// Authentication state with sealed class
sealed class AuthState {
  const AuthState();
}
class AuthInitial extends AuthState {
  const AuthInitial();
}
class AuthLoading extends AuthState {
  const AuthLoading();
}
class AuthAuthenticated extends AuthState {
  final User user;
  const AuthAuthenticated(this.user);
}
class AuthUnauthenticated extends AuthState {
  final String? error;
  const AuthUnauthenticated([this.error]);
}

// Notifier to manage auth state
class AuthNotifier extends StateNotifier<AuthState> {
  final AuthRepository _repository;
  final SecureStorage _storage;

  AuthNotifier(this._repository, this._storage) : super(const AuthInitial()) {
    _checkAuthStatus();
  }

  Future<void> _checkAuthStatus() async {
    final token = await _storage.getToken();
    if (token != null) {
      try {
        final user = await _repository.getCurrentUser(token);
        state = AuthAuthenticated(user);
      } catch (_) {
        await _storage.deleteToken();
        state = const AuthUnauthenticated();
      }
    } else {
      state = const AuthUnauthenticated();
    }
  }

  Future<void> login(String email, String password) async {
    state = const AuthLoading();
    try {
      final result = await _repository.login(email, password);
      await _storage.saveToken(result.token);
      state = AuthAuthenticated(result.user);
    } catch (e) {
      state = AuthUnauthenticated(e.toString());
    }
  }

  Future<void> logout() async {
    await _storage.deleteToken();
    state = const AuthUnauthenticated();
  }
}

// Provider with injected dependencies
final authProvider = StateNotifierProvider<AuthNotifier, AuthState>((ref) {
  return AuthNotifier(
    ref.watch(authRepositoryProvider),
    ref.watch(secureStorageProvider),
  );
});

// Redirect based on auth state
final routerProvider = Provider<GoRouter>((ref) {
  final authState = ref.watch(authProvider);

  return GoRouter(
    redirect: (context, state) {
      final isAuth = authState is AuthAuthenticated;
      final isAuthRoute = state.matchedLocation.startsWith('/auth');

      if (!isAuth && !isAuthRoute) return '/auth/login';
      if (isAuth && isAuthRoute) return '/home';
      return null;
    },
    routes: [...],
  );
});
```

### Authentifizierung mit BLoC

```dart
// auth_bloc.dart
// Exhaustive states for authentication
sealed class AuthState {
  const AuthState();
}
class AuthInitial extends AuthState {
  const AuthInitial();
}
class AuthCheckInProgress extends AuthState {
  const AuthCheckInProgress();
}
class AuthLoginInProgress extends AuthState {
  const AuthLoginInProgress();
}
class AuthSuccess extends AuthState {
  final User user;
  const AuthSuccess(this.user);
}
class AuthFailure extends AuthState {
  final String error;
  const AuthFailure(this.error);
}
class AuthLoggedOut extends AuthState {
  const AuthLoggedOut();
}

// Authentication events
sealed class AuthEvent {
  const AuthEvent();
}
class AuthCheckRequested extends AuthEvent {
  const AuthCheckRequested();
}
class AuthLoginSubmitted extends AuthEvent {
  final String email;
  final String password;
  const AuthLoginSubmitted(this.email, this.password);
}
class AuthLogoutRequested extends AuthEvent {
  const AuthLogoutRequested();
}

class AuthBloc extends Bloc<AuthEvent, AuthState> {
  final AuthRepository _repository;
  final SecureStorage _storage;

  AuthBloc({
    required AuthRepository repository,
    required SecureStorage storage,
  })  : _repository = repository,
        _storage = storage,
        super(const AuthInitial()) {
    on<AuthCheckRequested>(_onCheckRequested);
    on<AuthLoginSubmitted>(_onLoginSubmitted);
    on<AuthLogoutRequested>(_onLogoutRequested);
  }

  Future<void> _onCheckRequested(
    AuthCheckRequested event,
    Emitter<AuthState> emit,
  ) async {
    emit(const AuthCheckInProgress());
    final token = await _storage.getToken();

    if (token == null) {
      emit(const AuthLoggedOut());
      return;
    }

    try {
      final user = await _repository.getCurrentUser(token);
      emit(AuthSuccess(user));
    } catch (_) {
      await _storage.deleteToken();
      emit(const AuthLoggedOut());
    }
  }

  Future<void> _onLoginSubmitted(
    AuthLoginSubmitted event,
    Emitter<AuthState> emit,
  ) async {
    emit(const AuthLoginInProgress());
    try {
      final result = await _repository.login(event.email, event.password);
      await _storage.saveToken(result.token);
      emit(AuthSuccess(result.user));
    } catch (e) {
      emit(AuthFailure(e.toString()));
    }
  }

  Future<void> _onLogoutRequested(
    AuthLogoutRequested event,
    Emitter<AuthState> emit,
  ) async {
    await _storage.deleteToken();
    emit(const AuthLoggedOut());
  }
}
```

Beide Implementierungen behandeln dieselbe Funktionalität in unterschiedlichen Stilen. BLoC macht jeden Übergang explizit, Riverpod vereinfacht die Syntax.

## Vergleichstabelle Zusammenfassung

| Kriterium | Riverpod | BLoC |
|-----------|----------|------|
| **Lernkurve** | Moderat | Steiler |
| **Boilerplate** | Minimal | Erheblich |
| **Type Safety** | Hervorragend | Hervorragend |
| **Testbarkeit** | Hervorragend | Hervorragend |
| **Nachverfolgbarkeit** | Über DevTools | Explizite Events/States |
| **Komposition** | Automatisch | Manuell |
| **Codegenerierung** | Optional | Nicht erforderlich |
| **Teamgröße** | Flexibel | Große Teams |

## Empfehlungen je nach Kontext

Die Wahl zwischen Riverpod und BLoC hängt von mehreren kontextuellen Faktoren ab.

**Riverpod wählen, wenn:**
- Das Team Prägnanz und Produktivität priorisiert
- Das Projekt flexible State-Komposition erfordert
- Die Entwickler aus React oder anderen reaktiven Frameworks kommen
- Automatisches Caching einen erheblichen Vorteil darstellt

**BLoC wählen, wenn:**
- Das Team strikte, vorhersagbare Patterns schätzt
- Das Projekt vollständige Event-Nachverfolgbarkeit erfordert
- Junioren von einer durchgesetzten Architektur profitieren
- Debugging einen Übergangsverlauf benötigt

## Fazit

Riverpod und BLoC adressieren effektiv die Anforderungen des State Managements in Flutter. Riverpod glänzt durch Ergonomie und Flexibilität, BLoC durch Struktur und Vorhersagbarkeit. Beide Lösungen bieten exzellente Testbarkeit und optimale Leistung.

### Entscheidungs-Checkliste

- ✅ Teamgröße und Erfahrung bewerten
- ✅ Komplexität des Datenflusses berücksichtigen
- ✅ Anforderungen an Nachverfolgbarkeit und Debugging analysieren
- ✅ Beide Lösungen an einem Prototyp testen
- ✅ Konsistenz mit der bestehenden Architektur prüfen

Die beste Wahl bleibt diejenige, die das Team beherrscht und effektiv pflegt. Konsistenz in der Anwendung hat Vorrang vor der Wahl der Lösung selbst.

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/de/blog/flutter/flutter-state-management-riverpod-vs-bloc