Flutter 颤振将数据发送到其他屏幕而不使用导航器

我有一个问题，如何在没有导航器的情况下，仅使用onChanged和streambuilder在页面/屏幕之间传递数据

我想要的是，每当用户在第一个小部件上的textfield中写入内容时，第二个小部件就会用第一个小部件中的新数据自动刷新

这是我的first.dart代码

import 'package:flutter/material.dart';
import 'second.dart';

class First extends StatefulWidget {
  First({Key key}) : super(key: key);

  @override
  _FirstState createState() => _FirstState();
}

class _FirstState extends State<First> {
      final TextEditingController _myTextController =
        new TextEditingController(text: "");


  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: new AppBar(
        title: Text("Passing Data"),
      ),
      body: Column(
        children: <Widget>[
          Container(
            height: 120.0,
            child: Column(
              children: <Widget>[
                TextField(
                  controller: _myTextController,
                  onChanged: (String value) {
                    // refresh second with new data
                  },
                )
              ]
            )
          ),
          Container(
            height: 120.0,
            child: Second(
              myText: _myTextController.text,
            ),
          )
        ],
      ),
    );
  }
}

导入“包装：颤振/材料.省道”；
导入“second.dart”；
类首先扩展StatefulWidget{
第一（{Key}）：超级（Key:Key）；
@凌驾
_FirstState createState（）；
}
类_FirstState扩展了状态{
最终文本编辑控制器\u myTextController=
新文本编辑控制器（文本：“”）；
@凌驾
小部件构建（构建上下文）{
返回脚手架(
appBar：新的appBar(
标题：文本（“传递数据”），
),
正文：专栏(
儿童：[
容器(
身高：120.0，
子：列(
儿童：[
文本字段(
控制器：_myTextController，
onChanged:（字符串值）{
//用新数据刷新秒
},
)
]
)
),
容器(
身高：120.0，
孩子：第二(
myText:_myTextController.text，
),
)
],
),
);
}
}

这是我的第二个.dart，作为从第一个小部件接收数据的第二个小部件

导入'dart:async'；
进口“包装：颤振/材料.省道”；
导入“api_services.dart”；
第二类扩展StatefulWidget{
第二（{Key-Key，@required this.myText}）：super（Key:Key）；
最后一个字符串myText；
@凌驾
_SecondState createState（）；
}
类_SecondState扩展了状态{
StreamController dataController；
loadPosts（）异步{
getDetailData（widget.myText）。然后（（res）异步{
_dataController.add（res）；
返回res；
});
}
@凌驾
void initState（）{
_dataController=新的StreamController（）；
装载柱（）；
super.initState（）；
打印（widget.myText）；
}
@凌驾
小部件构建（构建上下文）{
返回流生成器(
流：_dataController.stream，
生成器：（BuildContext上下文，异步快照）{
if（snapshot.hasError）{
返回文本（snapshot.error）；
}
if（snapshot.hasData）{
返回容器（）；
}
if（snapshot.connectionState==connectionState.waiting）{
返回行(
儿童：[
文本（“请写一篇文本”），
],
);
}else if（snapshot.connectionState！=connectionState.active）{
返回循环ProgressIndicator（）；
}
如果（！snapshot.hasData）&&
snapshot.connectionState==connectionState.done）{
返回文本（“无数据”）；
}else if（snapshot.hasData&&snapshot.connectionState==connectionState.done）{
返回文本（widget.myText）；
}
返回null；
});
}
}

您有两个选择。最简单的两种方法是：将文本编辑控制器本身传递给第二个小部件，然后监听它并调用setState来更改第二个小部件中的文本

示例

class Second extends StatefulWidget {
  Second({Key key, @required this.textController}) : super(key: key);

  final TextEditingController textController;

  @override
  _SecondState createState() => _SecondState();
}

class _SecondState extends State<Second> {
// made this private
String _myText;

@override
void initState() {
  _myText = widget.textController.text
  widget.textController.addListener(() {
    setState((){_myText = widget.textController.text});
    );
  });
  super.initState();
}

...

// then in your build method, put this in place of return Text(widget.myText);
return Text(_myText);

class Second扩展StatefulWidget{
第二（{Key Key，@required this.textController}）：super（Key:Key）；
最终文本编辑控制器文本控制器；
@凌驾
_SecondState createState（）；
}
类_SecondState扩展了状态{
//把这件事保密
字符串_myText；
@凌驾
void initState（）{
_myText=widget.textController.text
widget.textController.addListener（（）{
setState（（）{u myText=widget.textController.text}）；
);
});
super.initState（）；
}
...
//然后在构建方法中，将其替换为返回文本（widget.myText）；
返回文本（_myText）；

选项2正在侦听第一个小部件中的控制器，并在其中调用setState。这将重建第一个和第二个小部件，但我认为性能不如第一个选项

---

希望这对阅读Redux或BLoC@Urma我对诸如redux/bloc/provider之类的状态管理非常熟悉，我只需要简单的状态来更新下一个屏幕。以及如何在没有导航器的情况下将它从第一个屏幕发送到第二个屏幕。of（context）？因为我只使用onChanged:（字符串值）{}使用我给您的示例，将第一个小部件中的

Second（myText:\u myTextController.text，），

更改为

Second（textController:\u myTextController）

Thx，我已经理解了您使用listener的解决方案。