Riverpod 學習筆記

• Naming consistency

// Without code generation
final userProvider = Provider<User>((ref) {
  final auth = ref.watch(authProvider);
  return User(auth.userId);
});

----

// With code generation
@riverpod
User user(UserRef ref) {
  final auth = ref.watch(authProvider);
  return User(auth.userId);
}

• Reduce the effort to manually define providers
• without needing to always extend notifiers from StateNotifier , just use _${name} instead

// Traditional approach
final counterProvider = StateNotifierProvider<CounterNotifier, int>((ref) {
  return CounterNotifier();
});

class CounterNotifier extends StateNotifier<int> {
  CounterNotifier() : super(0);
  
  void increment() => state = state + 1;
}

----

// Code generation approach with @riverpod annotation
@riverpod
class Counter extends _$Counter {
  @override
  int build() => 0;
  
  void increment() => state = state + 1;
}

// The generator creates counterProvider automatically

• auto generate type-safe processor

// Generated accessors (you don't write these)

// Access the provider itself
final counterProvider = _$counterProvider;

// Access just the notifier (for calling methods)
final counterNotifierProvider = _$counterNotifierProvider;

// Extension methods for cleaner access in widgets
extension CounterProviderExtension on AutoDisposeNotifierProviderRef<Counter, int> {
  // Type-safe methods for this specific provider
}

• automatic error handling (AsyncValue)

// Without code generation
// 1. Define the state notifier with dependencies
class UserRepositoryNotifier extends StateNotifier<AsyncValue<User>> {
  UserRepositoryNotifier(this.ref) : super(const AsyncValue.loading()) {
    fetchUser();
  }

  final Ref ref;

  Future<void> fetchUser() async {
    state = const AsyncValue.loading();
    try {
      final authService = ref.read(authServiceProvider);
      final userId = ref.read(userIdProvider);
      final user = await authService.getUser(userId);
      state = AsyncValue.data(user);
    } catch (e, stack) {
      state = AsyncValue.error(e, stack);
    }
  }
}

// 2. Manually create the provider with proper types
final userRepositoryProvider = StateNotifierProvider<UserRepositoryNotifier, AsyncValue<User>>((ref) {
  return UserRepositoryNotifier(ref);
});

----

// With code generation
// Single class with annotation handles everything
@riverpod
class UserRepository extends _$UserRepository {
  @override
  FutureOr<User> build() async {
    return fetchUser();
  }

  Future<User> fetchUser() async {
    state = const AsyncValue.loading();
    try {
      final authService = ref.read(authServiceProvider);
      final userId = ref.read(userIdProvider);
      return await authService.getUser(userId);
    } catch (e, stack) {
      // AsyncValue error handling is built-in
      throw e;
    }
  }
}

// userRepositoryProvider is automatically generated