RiverpodRef.Indistrate无效所有提供商

Question

@riverpod
class ParentHeader extends _$ParentHeader {
  @override
  FutureOr<bool> build(HeaderViewModel viewModel) async {
    return await parentHeader(viewModel);
  }

  Future<bool> parentHeader(HeaderViewModel headerVM) async {
    Trial? trial =
        await ref.watch(trialProvider.future);

    if (trial != null) {
        Future tasks =
            ref.watch(tasksProvider(headerVM.strStartDate, headerVM.strEndDate).future);

        Future video = ref
            .watch(videoProvider(headerVM.tmpStartDate, headerVM.tmpEndDate).future);

        Future calendar = ref.watch(
            calendarProvider(headerVM.strStartDate, headerVM.strEndDate).future);

        var listOfResponses =
            await Future.wait([tasks, calendar, video]);       

        return Future.value(true);
      }
  }

在一个事件中，我只想使

calendarProvider

无效。当我尝试这样做时，所有的3个提供商（API）再次被调用。但是没有叫

Future.wait

。
我正在使用的提供商的示例

trialProvider 我不确定我在做什么错。还是有其他方法可以实现这一目标？ 呼叫

@riverpod
class Calendar extends _$Calendar {
  @override
  FutureOr<List<CalendarModel>> build(String startDate, String endDate) async {
    List<CalendarModel> model = await calendarEvents(startDate, endDate);

    return model;
  }

  Future<List<CalendarModel>> calendarEvents(String startDate, String endDate) async {
    EndPoint endPoint = EndPoint();
    endPoint.parameters = {"from": startDate, "to": endDate};
    try {
      NetworkResponse? response = await _Api().fetch(endPoint);

      return response.when(success: (response) {
        List<CalendarModel> events = [];
        
        var responseMessage =
            CalendarModelResponse.fromJson(response.data);
        events = responseMessage.message;
        return Future.value(events);
      },
        error: (error) {
        debugPrint(" error -  ${error.message}");
      });
    } 
  }
}

正在添加异步差距。在那个差距期间，RiverPod正在处理任务，视频和日历提供商，因为他们没有任何订户。在异步差距完成后，每个提供商中的每一个都将转移给await ref.watch(trialProvider.future);

，RiverPod重新创建它们并重新运行API调用或您编写的其他逻辑。

最简单的方法是在任何异步差距之前执行所有

ref.watch

代码：

Answer 1

这将防止提供者处置，但稍微改变了提供者的行为：

parentHeader

现在将依赖于

Future<bool> parentHeader(HeaderViewModel headerVM) async {
  final trialFuture = ref.watch(trialProvider.future);

  final tasks = ref.watch(
    tasksProvider(headerVM.strStartDate, headerVM.strEndDate).future,
  );
  final video = ref.watch(
    videoProvider(headerVM.strStartDate, headerVM.strEndDate).future,
  );
  final calendar = ref.watch(
    calendarProvider(headerVM.strStartDate, headerVM.strEndDate).future,
  );

  if (await trialFuture != null) {
    var listOfResponses = await Future.wait([tasks, calendar, video]);
    return true;
  }

  // Other logic here

  return false;
}

，

parentHeaderProvider

和

tasksProvider

，即使

videoProvider

返回。这意味着，只要

calendarProvider

IS，这些提供商就会保持活力，并且任何一个更新的人都会导致

trialProvider

重建。根据您的应用，也许这很好，Riverpod的缓存逻辑意味着它不应在开销中产生太多。

如果您确实需要避免不必要地倾听这些提供商，则可以（AB）使用

null暂时保持活力，只有在异步差距期间已经初始化的提供商：

parentHeaderProvider