如何在Bloc返回相同NetworkErrorState时多次触发Bloc监听器？

这个问题本质是Bloc的状态更新规则导致的：由于你的NetworkErrorState通过props（包含failure和message）判断相等时，Bloc会认为状态没有发生变化，因此不会向监听器发送状态变更通知。要解决这个问题，核心就是让每次重试后的NetworkErrorState被判定为新状态，或者通过其他方式触发监听器逻辑。

下面提供几个实用的解决方案：

方案1：给错误状态添加唯一标识（推荐） #

给NetworkErrorState增加一个用于区分每次重试的字段，比如重试次数或者时间戳，让每次生成的状态props都不一样，这样Bloc就会识别为新状态并触发监听器。

修改状态类： #

class NetworkErrorState extends MyBlocState {
  final String message;
  final Failure failure;
  final int retryCount; // 新增：记录重试次数

  NetworkErrorState({
    this.failure,
    this.message,
    this.retryCount = 0, // 默认0
  });

  @override
  List<Object> get props => [failure, message, retryCount]; // 将retryCount加入props
}

在Bloc中处理重试事件： #

当用户点击重试按钮时，在事件处理逻辑中递增retryCount：

on<RetryEvent>((event, emit) async {
  try {
    // 尝试重新发起请求
    final data = await yourRepository.fetchData();
    emit(LoadedState(data));
  } catch (e) {
    // 获取当前状态的重试次数（如果当前已是错误状态）
    final currentRetryCount = state is NetworkErrorState 
        ? (state as NetworkErrorState).retryCount 
        : 0;

    // 发送带新重试次数的错误状态
    emit(NetworkErrorState(
      failure: ServerFailure(message: e.toString()),
      message: "网络连接失败，请重试",
      retryCount: currentRetryCount + 1,
    ));
  }
});

这个方案的优点是侵入性小，不需要额外状态，完全利用Bloc本身的状态更新机制。

方案2：插入临时过渡状态 #

在重试时先发送一个“正在重试”的过渡状态，再发送NetworkErrorState。这样即使最终的错误状态和之前相同，由于中间有状态变化，监听器也会被触发。

新增过渡状态： #

class RetryingState extends MyBlocState {
  @override
  List<Object> get props => [];
}

修改Bloc事件处理： #

on<RetryEvent>((event, emit) async {
  // 先发送重试中状态
  emit(RetryingState());
  
  try {
    final data = await yourRepository.fetchData();
    emit(LoadedState(data));
  } catch (e) {
    // 再发送错误状态
    emit(NetworkErrorState(
      failure: ServerFailure(message: e.toString()),
      message: "网络连接失败，请重试",
    ));
  }
});

调整BlocListener： #

确保监听器能处理RetryingState和NetworkErrorState：

BlocListener<MyBloc, MyBlocState>(
  listener: (context, state) {
    if (state is RetryingState) {
      // 可以显示加载提示
    } else if (state is NetworkErrorState) {
      // 显示错误提示和重试按钮
    }
  },
  child: ...,
)

这个方案适合需要在重试时展示加载状态的场景，同时也能保证错误状态的监听器被触发。

方案3：直接触发监听器逻辑（绕过状态判断） #

如果不想修改状态结构，也可以在Bloc中通过自定义回调的方式，直接通知UI执行错误处理逻辑。比如在Bloc中定义一个Stream，专门用于发送错误通知：

在Bloc中添加错误通知流： #

class MyBloc extends Bloc<MyEvent, MyBlocState> {
  final StreamController<Failure> _errorNotificationController = StreamController.broadcast();
  Stream<Failure> get errorNotification => _errorNotificationController.stream;

  MyBloc() : super(InitialState()) {
    on<RetryEvent>((event, emit) async {
      try {
        final data = await yourRepository.fetchData();
        emit(LoadedState(data));
      } catch (e) {
        final failure = ServerFailure(message: e.toString());
        // 发送状态（即使和之前相同）
        emit(NetworkErrorState(failure: failure, message: "网络连接失败，请重试"));
        // 同时发送错误通知
        _errorNotificationController.add(failure);
      }
    });
  }

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

在UI中监听这个流： #

@override
void initState() {
  super.initState();
  context.read<MyBloc>().errorNotification.listen((failure) {
    // 执行错误提示逻辑
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(content: Text(failure.message)),
    );
  });
}

这个方案适合不需要依赖状态变化，只想直接触发UI逻辑的场景，但需要手动管理流的生命周期。

内容的提问来源于stack exchange，提问作者unice