Riverpod vs Bloc Comparison

// Riverpod - User list (with code generation)
// Source: official riverpod.dev documentation pattern
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:riverpod_annotation/riverpod_annotation.dart';

part 'user_list_provider.g.dart';

@riverpod
Future<List<User>> userList(Ref ref, {required int page}) async {
  final repository = ref.watch(userRepositoryProvider);
  return repository.fetchUsers(page: page);
}

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

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final usersAsync = ref.watch(userListProvider(page: 1));

    return usersAsync.when(
      data: (users) => ListView.builder(
        itemCount: users.length,
        itemBuilder: (context, index) => ListTile(
          title: Text(users[index].name),
          subtitle: Text(users[index].email),
        ),
      ),
      loading: () => const Center(child: CircularProgressIndicator()),
      error: (error, stack) => Center(child: Text('Hata: $error')),
    );
  }
}

// Codegen-free classic syntax alternative (official docs, optional):
final userListClassicProvider =
    FutureProvider.autoDispose.family<List<User>, int>((ref, page) async {
  final repository = ref.watch(userRepositoryProvider);
  return repository.fetchUsers(page: page);
});

// Bloc - User list (Event/State + Repository)
// Source: official bloclibrary.dev Core Concepts pattern
import 'package:flutter_bloc/flutter_bloc.dart';

sealed class UserListEvent {}

class FetchUsers extends UserListEvent {
  FetchUsers({required this.page});
  final int page;
}

sealed class UserListState {}

class UserListInitial extends UserListState {}

class UserListLoading extends UserListState {}

class UserListLoaded extends UserListState {
  UserListLoaded({required this.users});
  final List<User> users;
}

class UserListError extends UserListState {
  UserListError({required this.message});
  final String message;
}

class UserListBloc extends Bloc<UserListEvent, UserListState> {
  UserListBloc({required this.repository}) : super(UserListInitial()) {
    on<FetchUsers>(_onFetchUsers);
  }

  final UserRepository repository;

  Future<void> _onFetchUsers(
    FetchUsers event,
    Emitter<UserListState> emit,
  ) async {
    emit(UserListLoading());
    try {
      final users = await repository.fetchUsers(page: event.page);
      emit(UserListLoaded(users: users));
    } catch (error) {
      emit(UserListError(message: error.toString()));
    }
  }
}