Question

我认为，现在我了解transform()类中的Bloc.dart发生了什么。 BloC.dart的构造函数中的ScanStreamTransformer被每个侦听器调用一次（One.dart类中有3个侦听器，因此被调用3次）。我想更改此行为，以便每个事件都调用一次，无论连接了多少个侦听器，例如调用_mainBloc.inValue(widget.value)只会调用一次转换，现在调用了3次，因为streamBuilder() build（）函数内部有3个侦听器（请参见One.dart）。

与以前的帖子（现在已删除）相比，我希望这更加清晰。

class OneState extends State<One>{


  @override
  void didChangeDependencies() {
    super.didChangeDependencies();
    _mainBloc.inValue(widget.value);
  }
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(),
      body: Column(
        children: <Widget>[
         streamBuilder(),
         streamBuilder(),
         streamBuilder()
        ],
      ),
    );
  }

  streamBuilder(){
    return           StreamBuilder(
      stream: _mainBloc.values$,
      builder: (context, AsyncSnapshot<Map<String, Future<String>>> snapshot){
        if(snapshot.connectionState  == ConnectionState.waiting) return Center(child: Container(child: new CircularProgressIndicator()));
        if(!snapshot.hasData) return Center(child: Container(child: Text("No Data"),));
        return FutureBuilder(
          future: snapshot.data[widget.value],
          builder: (contextFuture, AsyncSnapshot<String> snapshotFuture){
            if(snapshotFuture.connectionState == ConnectionState.waiting)
              return Center(child: Container(child: new CircularProgressIndicator()));

            return Center(
              child: Container(
                child: Text(snapshotFuture.data),
              ),
            );
          },
        );
      },
    );
  }

}

BloC

class MainBloc{
  final ApiRequest _provider;

  MainBloc(this._provider){
    values$ = _value.stream.transform(
        ScanStreamTransformer((Map<String, Future<String>> cache, String symbol, index){
          print('transformer');
          cache[symbol] = _provider.fetchData();
          return cache;
        },
          <String, Future<String>>{},
        ));
  }

  final _value = BehaviorSubject<String>();

  Observable<Map<String, Future<String>>> values$;

  Function(String symbol) get inValue => _value.sink.add;


  dispose(){
    _value.close();
  }

}

Answer 1

添加一个.asBroadcastStream()。喜欢：

values$ =_value.stream.transform(
        ScanStreamTransformer((Map<String, Future<String>> cache, String symbol, index){
          print('transformer');
          cache[symbol] = _provider.fetchData();
          return cache;
        },
          <String, Future<String>>{},
        )).asBroadcastStream();

它应该停止三次通话。

ScanStreamTransformer替代方案，每个事件调用一次，而不是每个侦听器调用一次

1 个答案: