Dart firebase侦听中的for循环未更新

在我的应用程序中，我希望调用来自firebase不同集合的数据。首先，我要列出所有项目并获取id。 使用该id，我想从价格集合中检索价格。之后，我想从折扣中检索数据。谢谢你打折。 这里我使用循环。 在下面的代码中，输出即将出现。第一个加载列表，然后调用第二个收集价格。 任何人都知道解决办法。 我想听你打电话给三个收银员。因为如果有任何数据改变，我想更新

    @override
    void initState() {
        super.initState();
        _loadItems();
    }


    Future _loadItems() async {

            int price;
            int discount;

            //calling first collection for getting id and name
            firestore.collection("item").snapshots().listen((itemData)async{

                for(int i=0;i<itemData.documents.length;i++){

                // calling second collection for getting price
                firestore.collection("price").where("id",isEqualTo: itemData.documents[i].data["id"])
                .snapshots().listen((priceData) async{
                        price=priceData.documents[0].data['price'];
                        debugPrint("price showing before loading:"+price.toString());

                                //calling third collection for getting discount
                                firestore.collection("discount")
                                .where("id",isEqualTo: itemData.documents[i].data["id"])
                                .snapshots().listen((discountData) async{
                                    for(int j=0;j<discountData.documents.length;j++){
                                        discount=discountData.documents.data['discount'];
                                    }
                                });

                });

                    setState(() {
                    debugPrint("price showing after loading:"+price.toString());
                    this.documents.add(new CartProduct(
                        name:itemData.documents[i].data["id"],
                        label:itemData.documents[i].data["label"],
                        price:price,
                        discount:discount

                    ));
                    });

                }
        });


    }

预期产量

---

我想您可以使用嵌套的StreamBuilder

Widget getTripleCollectionFromFirebase() {
  return StreamBuilder<QuerySnapshot>(
    stream: Firestore.instance.collection("item").snapshots(),
    builder: (BuildContext context, AsyncSnapshot<QuerySnapshot> snapshot) {
      if (snapshot.hasError) return Text("Error: ${snapshot.error}");
      switch (snapshot.connectionState) {
        case ConnectionState.none:
          return Text("No data, yet.");
        case ConnectionState.waiting:
          return Text('Loading...');
        case ConnectionState.active:
        case ConnectionState.done:
          if (snapshot.data == null) {
            return Text("No record");
          } else {
            // Do your staff after first query then call the other collection
            return StreamBuilder<QuerySnapshot>(
              stream: Firestore.instance
                  .collection("price")
                  .where("id", isEqualTo: "fill_it_with_your_code")
                  .snapshots(),
              builder: (BuildContext context,
                  AsyncSnapshot<QuerySnapshot> snapshot) {
                if (snapshot.hasError) return Text("Error: ${snapshot.error}");
                switch (snapshot.connectionState) {
                  case ConnectionState.none:
                    return Text("No data, yet.");
                  case ConnectionState.waiting:
                    return Text('Loading...');
                  case ConnectionState.active:
                  case ConnectionState.done:
                    if (snapshot.data == null) {
                      return Text("No record");
                    } else {
                      // do your staff after second Query
                      return StreamBuilder<QuerySnapshot>(
                        stream: Firestore.instance
                            .collection("discount")
                            .where("id", isEqualTo: "something")
                            .snapshots(),
                        builder: (BuildContext context,
                            AsyncSnapshot<QuerySnapshot> snapshot) {
                          if (snapshot.hasError)
                            return Text("Error: ${snapshot.error}");
                          switch (snapshot.connectionState) {
                            case ConnectionState.none:
                              return Text("No data, yet.");
                            case ConnectionState.waiting:
                              return Text('Loading...');
                            case ConnectionState.active:
                            case ConnectionState.done:
                              if (snapshot.data == null) {
                                return Text("No record");
                              } else {
                                // do your staff after third Query
                                // return the widget which you want to build when all data comes.
                              }
                          }
                        },
                      );
                    }
                }
              },
            );
          }
      }
    },
  );
}

Widget getTripleCollectionFromFirebase（）{
返回流生成器(
流：Firestore.instance.collection（“项”）.snapshots（），
生成器：（BuildContext上下文，异步快照）{
if（snapshot.hasError）返回文本（“Error:${snapshot.Error}”）；
交换机（快照.连接状态）{
案例连接状态。无：
返回文本（“还没有数据”）；
案例连接状态。正在等待：
返回文本（'加载…'）；
案例连接状态.active：
案例连接状态。完成：
如果（snapshot.data==null）{
返回文本（“无记录”）；
}否则{
//请您的员工在第一次查询后再致电其他集合
返回流生成器(
流：Firestore.instance
.收款（“价格”）
。其中（“id”，isEqualTo:“用您的代码填充它”）
.snapshots（），
生成器：（BuildContext上下文，
异步快照（快照）{
if（snapshot.hasError）返回文本（“Error:${snapshot.Error}”）；
交换机（快照.连接状态）{
案例连接状态。无：
返回文本（“还没有数据”）；
案例连接状态。正在等待：
返回文本（'加载…'）；
案例连接状态.active：
案例连接状态。完成：
如果（snapshot.data==null）{
返回文本（“无记录”）；
}否则{
//你的员工在第二次询问后
返回流生成器(
流：Firestore.instance
.收款（“折扣”）
.where（“id”，isEqualTo：“某物”）
.snapshots（），
生成器：（BuildContext上下文，
异步快照（快照）{
if（snapshot.hasError）
返回文本（“错误：${snapshot.Error}”）；
交换机（快照.连接状态）{
案例连接状态。无：
返回文本（“还没有数据”）；
案例连接状态。正在等待：
返回文本（'加载…'）；
案例连接状态.active：
案例连接状态。完成：
如果（snapshot.data==null）{
返回文本（“无记录”）；
}否则{
//你的员工在第三次询问后
//返回所有数据到达时要构建的小部件。
}
}
},
);
}
}
},
);
}
}
},
);
}

我建议您使用嵌套StreamBuilder

Widget getTripleCollectionFromFirebase() {
  return StreamBuilder<QuerySnapshot>(
    stream: Firestore.instance.collection("item").snapshots(),
    builder: (BuildContext context, AsyncSnapshot<QuerySnapshot> snapshot) {
      if (snapshot.hasError) return Text("Error: ${snapshot.error}");
      switch (snapshot.connectionState) {
        case ConnectionState.none:
          return Text("No data, yet.");
        case ConnectionState.waiting:
          return Text('Loading...');
        case ConnectionState.active:
        case ConnectionState.done:
          if (snapshot.data == null) {
            return Text("No record");
          } else {
            // Do your staff after first query then call the other collection
            return StreamBuilder<QuerySnapshot>(
              stream: Firestore.instance
                  .collection("price")
                  .where("id", isEqualTo: "fill_it_with_your_code")
                  .snapshots(),
              builder: (BuildContext context,
                  AsyncSnapshot<QuerySnapshot> snapshot) {
                if (snapshot.hasError) return Text("Error: ${snapshot.error}");
                switch (snapshot.connectionState) {
                  case ConnectionState.none:
                    return Text("No data, yet.");
                  case ConnectionState.waiting:
                    return Text('Loading...');
                  case ConnectionState.active:
                  case ConnectionState.done:
                    if (snapshot.data == null) {
                      return Text("No record");
                    } else {
                      // do your staff after second Query
                      return StreamBuilder<QuerySnapshot>(
                        stream: Firestore.instance
                            .collection("discount")
                            .where("id", isEqualTo: "something")
                            .snapshots(),
                        builder: (BuildContext context,
                            AsyncSnapshot<QuerySnapshot> snapshot) {
                          if (snapshot.hasError)
                            return Text("Error: ${snapshot.error}");
                          switch (snapshot.connectionState) {
                            case ConnectionState.none:
                              return Text("No data, yet.");
                            case ConnectionState.waiting:
                              return Text('Loading...');
                            case ConnectionState.active:
                            case ConnectionState.done:
                              if (snapshot.data == null) {
                                return Text("No record");
                              } else {
                                // do your staff after third Query
                                // return the widget which you want to build when all data comes.
                              }
                          }
                        },
                      );
                    }
                }
              },
            );
          }
      }
    },
  );
}

Widget getTripleCollectionFromFirebase（）{
返回流生成器(
流：Firestore.instance.collection（“项”）.snapshots（），
生成器：（BuildContext上下文，异步快照）{
if（snapshot.hasError）返回文本（“Error:${snapshot.Error}”）；
交换机（快照.连接状态）{
案例连接状态。无：
返回文本（“还没有数据”）；
案例连接状态。正在等待：
返回文本（'加载…'）；
案例连接状态.active：
案例连接状态。完成：
如果（snapshot.data==null）{
返回文本（“无记录”）；
}否则{
//请您的员工在第一次查询后再致电其他集合
返回流生成器(
流：Firestore.instance
.收款（“价格”）
。其中（“id”，isEqualTo:“用您的代码填充它”）
.snapshots（），
生成器：（BuildContext上下文，
异步快照（快照）{
if（snapshot.hasError）返回文本（“Error:${snapshot.Error}”）；
交换机（快照.连接状态）{
案例连接状态。无：
返回文本（“还没有数据”）；
案例连接状态。正在等待：
返回文本（'加载…'）；
案例连接状态.active：
案例连接状态。完成：
如果（snapshot.data==null）{
返回文本（“无记录”）；
}否则{
//你的员工在第二次询问后
返回流生成器(
流：Firestore.instance
.收款（“折扣”）
.where（“id”，isEqualTo：“某物”）
.snapshots（），
生成器：（BuildContext上下文，
异步快照（快照）{
if（snapshot.hasError）
返回文本（“错误：${snapshot.Error}”）；
交换机（快照.连接状态）{
案例连接状态。无：
返回文本（“还没有数据”）；
Widget getTripleCollectionFromFirebase() {
  return StreamBuilder<QuerySnapshot>(
    stream: Firestore.instance.collection("item").snapshots(),
    builder: (BuildContext context, AsyncSnapshot<QuerySnapshot> snapshot) {
      if (snapshot.hasError) return Text("Error: ${snapshot.error}");
      switch (snapshot.connectionState) {
        case ConnectionState.none:
          return Text("No data, yet.");
        case ConnectionState.waiting:
          return Text('Loading...');
        case ConnectionState.active:
        case ConnectionState.done:
          if (snapshot.data == null) {
            return Text("No record");
          } else {
            // Do your staff after first query then call the other collection
            return StreamBuilder<QuerySnapshot>(
              stream: Firestore.instance
                  .collection("price")
                  .where("id", isEqualTo: "fill_it_with_your_code")
                  .snapshots(),
              builder: (BuildContext context,
                  AsyncSnapshot<QuerySnapshot> snapshot) {
                if (snapshot.hasError) return Text("Error: ${snapshot.error}");
                switch (snapshot.connectionState) {
                  case ConnectionState.none:
                    return Text("No data, yet.");
                  case ConnectionState.waiting:
                    return Text('Loading...');
                  case ConnectionState.active:
                  case ConnectionState.done:
                    if (snapshot.data == null) {
                      return Text("No record");
                    } else {
                      // do your staff after second Query
                      return StreamBuilder<QuerySnapshot>(
                        stream: Firestore.instance
                            .collection("discount")
                            .where("id", isEqualTo: "something")
                            .snapshots(),
                        builder: (BuildContext context,
                            AsyncSnapshot<QuerySnapshot> snapshot) {
                          if (snapshot.hasError)
                            return Text("Error: ${snapshot.error}");
                          switch (snapshot.connectionState) {
                            case ConnectionState.none:
                              return Text("No data, yet.");
                            case ConnectionState.waiting:
                              return Text('Loading...');
                            case ConnectionState.active:
                            case ConnectionState.done:
                              if (snapshot.data == null) {
                                return Text("No record");
                              } else {
                                // do your staff after third Query
                                // return the widget which you want to build when all data comes.
                              }
                          }
                        },
                      );
                    }
                }
              },
            );
          }
      }
    },
  );
}


  QuerySnapshot _lastActionDocuments;
  Stream<String> streamOfFillActionFields;

  Widget buildUserActions() {
    return StreamBuilder(
      initialData: _lastActionDocuments,
      stream: Firestore.instance.collection('actions').snapshots(),
      builder: (BuildContext context, AsyncSnapshot<QuerySnapshot> snapshot) {
        switch (snapshot.connectionState) {
          case ConnectionState.none:
          case ConnectionState.waiting:
            return Center(
              child: CircularProgressIndicator(),
            );
          case ConnectionState.active:
          case ConnectionState.done:
            if (snapshot.hasError)
              return Center(child: Text('Error: ${snapshot.error}'));
            if (!snapshot.hasData) return Text('No data finded!');
            _lastActionDocuments = snapshot.data;
            streamOfFillActionFields = fillActionFields();
            return reallyBuildActions();
        }
      },
    );
  }


  Stream<String> fillActionFields() async* {
    try {
      List<ActionModel> newActionList = [];
      for (DocumentSnapshot actionSnapshot in _lastActionDocuments.documents) {
        var currentAction = ActionModel.fromSnapshot(actionSnapshot);
        // I awaiting to get and fill all data.
        await currentAction.fillAllFields();
        newActionList.add(currentAction);
      }
      actionList = newActionList;
      // what I yield is not important this case 
      yield 'data';
    } catch (e) {
      print(e);
      yield 'nodata';
    }
  }


  Future<void> fillAllFields() async {
    DocumentSnapshot ownerSnapshot = await ownerRef.get();
    owner = UserModel.fromSnapshot(ownerSnapshot);
    DocumentSnapshot routeSnapshot = await routeRef.get();
    route = RouteModel.fromSnapshot(routeSnapshot);
  }

  Widget reallyBuildActions() {
    return StreamBuilder(
      stream: streamOfFillActionFields,
      builder: (BuildContext context, AsyncSnapshot<String> snapshot) {
        switch (snapshot.connectionState) {
          case ConnectionState.none:
          case ConnectionState.waiting:
            return Center(
              child: CircularProgressIndicator(),
            );
          case ConnectionState.active:
          case ConnectionState.done:
            if (snapshot.data == 'data') {
              return buildAllActions();
            } else {
              return Center(
                child: Column(
                  children: <Widget>[
                    CircularProgressIndicator(),
                    Text('Data Loading...')
                  ],
                ),
              );
            }
        }
      },
    );
  }


    StreamSubscription<QuerySnapshot> streamSub1;
    StreamSubscription<QuerySnapshot> streamSub2;
    StreamSubscription<QuerySnapshot> streamSub3;

    var list = new List();


    _loadItems() {

                int price;
                int discount;

                int count =1;

                //calling first collection for getting id and name
            streamSub1= firestore.collection("item").snapshots().listen((itemData)async{


                    for(int i=0;i<itemData.documents.length;i++){
                        list.add(id:itemData.documents[0].data['id'],name:itemData.documents[0].data['id');

                        if(onFavData.documents.length==productCount){
                            debugPrint("loop completed");
                            _loadPrice();
                        }
                    }


            });


    }

    void _loadPrice(){
    streamSub1.cancel();

    int count =1;

    for(int i=0;i<list.length;i++){
        streamSub2= firestore.collection("price").where("id",isEqualTo: itemData.documents[i].data["id"])
                    .snapshots().listen((priceData) async{
                    list[i].price= priceData['price'];
                    if(count==list.length){
                debugPrint("loop completed");
                _loadDiscount();
                }

        });

    }

    }

    _loadDiscount();{
    streamSub2.cancel();

    int count =1;

    for(int i=0;i<list.length;i++){
        streamSub3= firestore.collection("price").where("id",isEqualTo: itemData.documents[i].data["id"])
                    .snapshots().listen((priceData) async{
                    list[i].discount= priceData['price'];
                    if(count==list.length){
                debugPrint("loop completed");

                }

        });

    }

    }