Dart 如何修复FutureBuilder打开多次错误？

这是我的两门课（两页）。这两门课开了好几次。 我将futurebuilder中的调试点分为两个类。 调试点正在运行

MainCategory页并进入下一页

子类别页，然后再次运行主类别页（上一页）futurebuilder，然后再次运行主类别页futurebuilder

将子类别页导航到运行子类别页和主类别页的第三页

我将我的两个类上传到GitHub，请让我知道问题所在

主要类别代码：

---

子类别代码：

如文档中所述，您不应该在小部件的构建事件期间获取Futurebuilder的未来

未来必须提前获得，例如在 State.initState、State.didUpdateConfig或 State.didChangeDependencies。在测试过程中不得创建它 构造时调用State.build或StatelessWidget.build方法 未来建设者。如果未来与 FutureBuilder，然后每次重建FutureBuilder的父对象时， 异步任务将重新启动

因此，尝试将对

getRegister

方法的调用移到build方法之外，并用返回的未来值替换它

例如，下面我有一个类，它返回一个未来值，该值将在FutureBuilder的帮助下使用

class MyApiHelper{

  static Future<List<String>> getMyList() async {
    // your implementation to make server calls
    return List<String>();
  }
}

类MyApiHelper{
静态未来getMyList（）异步{
//您的实现需要进行服务器调用
返回列表（）；
}
}

现在，在您的小部件中，您将有如下内容：

class _MyHomePageState extends State<MyHomePage> {

  Future<List<String>> _myList;

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

    _myList = MyApiHelper.getMyList();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(body: FutureBuilder(
      future: _myList,
      builder: (_, AsyncSnapshot<List<String>> snapLs) {
        if(!snapLs.hasData) return CircularProgressIndicator();

        return ListView.builder(
          itemCount: snapLs.data.length,
          itemBuilder: (_, index) {
            //show your list item row here...
          },
        );
      },
    ));
  }
}

class\u MyHomePageState扩展状态{
未来(myList),；
@凌驾
void initState（）{
super.initState（）；
_myList=MyApiHelper.getMyList（）；
}
@凌驾
小部件构建（构建上下文）{
返回脚手架（主体：FutureBuilder(
未来：_myList，
生成器：（\uux，异步快照快照）{
if（！snapLs.hasData）返回CircularProgressIndicator（）；
返回ListView.builder(
itemCount:snapLs.data.length，
itemBuilder:（\ux，索引）{
//在此处显示您的列表项行。。。
},
);
},
));
}
}

如上所示，Future在

initState

函数中获取，并在

build

方法中使用，由

FutureBuilder

使用

我希望这是有帮助的。

---

谢谢。

如果您碰巧使用了提供商，根据您的问题，这里（我认为）有一个更清晰的选择：

class MyHomePage扩展了无状态小部件{
@凌驾
小部件构建（构建上下文）{
返回未来提供者(
创建：（）=>MyApiHelper.getMyList（），
儿童：消费者(
建筑商：（uu，列表，uu）{
if（list==null）返回CircularProgressIndicator（）；
返回ListView.builder(
itemCount:list.length，
itemBuilder:（\ux，索引）{
//在此处显示您的列表项行。。。
},
);
};
),
);
}
}

---

当然，这也可以通过另一个答案所建议的

StatefulWidget

来实现，或者甚至可以通过

flatter\u hooks

来实现，如

中所述，您可以创建新的Widget并将函数传递给

returnFuture

as

() {
 return YourFuture;
} 

导入“dart:developer”；
进口“包装：颤振/材料.省道”；
类MyFutureBuilder扩展StatefulWidget{
最终未来函数（）返回未来；
最终的非同步构建器；
最终数据；
我的未来建设者({
这就是未来，
@需要这个.builder，
这是原始数据，
关键点，
})：super（key:key）；
@凌驾
_MyFutureBuilderState createState（）=>\u MyFutureBuilderState（）；
}
类_MyFutureBuilderState扩展状态{
bool isLoading=false；
未来；
@凌驾
void initState（）{
super.initState（）；
future=widget.returnFuture（）；
}
@凌驾
小部件构建（构建上下文）{
回归未来建设者(
生成器：widget.builder，
initialData:widget.initialData，
未来:未来,，
);
}
}

范例

MyFutureBuilder<List<User>>(
                                  returnFuture: () {
                                    return moderatorUserProvider
                                        .getExecutorsAsModeratorByIds(val.users,
                                            save: true);
                                  },
                                  builder: (cont, asyncData) {

                                    if (asyncData.connectionState !=
                                        ConnectionState.done) {
                                      return Center(
                                        child: MyCircularProgressIndicator(
                                          color: ModeratorColor.executors.color,
                                        ),
                                      );
                                    }
                                    return Column(
                                        children: asyncData.data
                                            .map(
                                              (singlExecutor) =>
                                                  ChooseInfoButton(
                                                title:
                                                    '${singlExecutor.firstName} ${singlExecutor.secondName}',
                                                subTitle: 'Business analyst',
                                                middleText: '4.000 NOK',
                                                subMiddleText: 'full time',
                                                label: 'test period',
                                                subLabel: '1.5 month',
                                                imageUrl:
                                                    assetsUrl + 'download.jpeg',
                                                onTap: () {
                                                  Navigator.of(context).push(
                                                    MaterialPageRoute(
                                                      builder: (_) =>
                                                          ModeratorExecutorEditPage(),
                                                    ),
                                                  );
                                                },
                                              ),
                                            )
                                            .toList());
                                  },
                                )
    ```

MyFutureBuilder(
返回未来：（）{
返回版主用户提供程序
.getExecutorsAsModeratorByIds（val.users，
保存：正确）；
},
生成器：（续，异步数据）{
如果（asyncData.connectionState=
连接状态（完成）{
返回中心(
儿童：MyCircularProgressIndicator(
颜色：版主颜色。执行者颜色，
),
);
}
返回列(
子项：asyncData.data
.地图(
（单执行器）=>
选择信息按钮(
标题：
“${singlExecutor.firstName}${singlExecutor.secondName}”，
副标题：“业务分析师”，
中间文本：“4000挪威克朗”，
SubmitDeleteText:“全职”，
标签：“测试周期”，
子标签：“1.5个月”，
图像URL：
assetsUrl+“下载.jpeg”，
MyFutureBuilder<List<User>>(
                                  returnFuture: () {
                                    return moderatorUserProvider
                                        .getExecutorsAsModeratorByIds(val.users,
                                            save: true);
                                  },
                                  builder: (cont, asyncData) {

                                    if (asyncData.connectionState !=
                                        ConnectionState.done) {
                                      return Center(
                                        child: MyCircularProgressIndicator(
                                          color: ModeratorColor.executors.color,
                                        ),
                                      );
                                    }
                                    return Column(
                                        children: asyncData.data
                                            .map(
                                              (singlExecutor) =>
                                                  ChooseInfoButton(
                                                title:
                                                    '${singlExecutor.firstName} ${singlExecutor.secondName}',
                                                subTitle: 'Business analyst',
                                                middleText: '4.000 NOK',
                                                subMiddleText: 'full time',
                                                label: 'test period',
                                                subLabel: '1.5 month',
                                                imageUrl:
                                                    assetsUrl + 'download.jpeg',
                                                onTap: () {
                                                  Navigator.of(context).push(
                                                    MaterialPageRoute(
                                                      builder: (_) =>
                                                          ModeratorExecutorEditPage(),
                                                    ),
                                                  );
                                                },
                                              ),
                                            )
                                            .toList());
                                  },
                                )
    ```