我正在使用Provider Package在Flutter App中管理状态。当我开始嵌套对象时，我遇到了问题。
一个非常简单的示例：父A有一个B型的孩子，它有一个C型的孩子，这个孩子有D型的孩子。在孩子D中，我要管理颜色属性。下面的代码示例：
import 'package:flutter/material.dart';
class A with ChangeNotifier
{
A() {_b = B();}
B _b;
B get b => _b;
set b(B value)
{
_b = value;
notifyListeners();
}
}
class B with ChangeNotifier
{
B() {_c = C();}
C _c;
C get c => _c;
set c(C value)
{
_c = value;
notifyListeners();
}
}
class C with ChangeNotifier
{
C() {_d = D();}
D _d;
D get d => _d;
set d(D value)
{
_d = value;
notifyListeners();
}
}
class D with ChangeNotifier
{
int _ColorIndex = 0;
final List<Color> _ColorList = [
Colors.black,
Colors.blue,
Colors.green,
Colors.purpleAccent
];
D()
{
_color = Colors.red;
}
void ChangeColor()
{
if(_ColorIndex < _ColorList.length - 1)
{
_ColorIndex++;
}
else
{
_ColorIndex = 0;
}
color = _ColorList[_ColorIndex];
}
Color _color;
Color get color => _color;
set color(Color value)
{
_color = value;
notifyListeners();
}
}
现在，我的 main.dart （正在管理我的Placeholder()小部件）包含以下内容：
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:provider_example/NestedObjects.dart';
void main() => runApp(MyApp());
class MyApp extends StatelessWidget
{
@override
Widget build(BuildContext context)
{
return MaterialApp(
home: ChangeNotifierProvider<A>(
builder: (context) => A(),
child: MyHomePage()
),
);
}
}
class MyHomePage extends StatefulWidget
{
@override
State createState()
{
return _MyHomePageState();
}
}
class _MyHomePageState extends State<MyHomePage>
{
@override
Widget build(BuildContext context)
{
A a = Provider.of<A>(context);
B b = a.b;
C c = b.c;
D d = c.d;
return Scaffold(
body: Center(
child: Column(
children: <Widget>[
Text(
'Current selected Color',
),
Placeholder(color: d.color,),
],
),
),
floatingActionButton: FloatingActionButton(
onPressed: () => ButtonPressed(context),
tooltip: 'Increment',
child: Icon(Icons.arrow_forward),
),
);
}
void ButtonPressed(BuildContext aContext)
{
A a = Provider.of<A>(context);
B b = a.b;
C c = b.c;
D d = c.d;
d.ChangeColor();
}
}
上面显示了 Placeholder Widget 的color属性由 D类的color属性(A -> B -> C -> D.color)定义。上面的代码经过了极大简化，但确实显示了我遇到的问题。
回到重点：如何将子D 的color属性分配给小部件，以便在更新子D 时的属性，它还会自动更新窗口小部件（使用notifyListeners()，而不是setState()）。
我使用了无状态，有状态， Provider.of 和 Consumer ，所有这些使我同样的结果。重申一下，对象不能分离，它必须具有父子关系。
编辑
更复杂的示例：
import 'dart:ui';
enum Manufacturer
{
Airbus, Boeing, Embraer;
}
class Fleet
{
List<Aircraft> Aircrafts;
}
class Aircraft
{
Manufacturer AircraftManufacturer;
double EmptyWeight;
double Length;
List<Seat> Seats;
Map<int,CrewMember> CrewMembers;
}
class CrewMember
{
String Name;
String Surname;
}
class Seat
{
int Row;
Color SeatColor;
}
上面的代码是真实示例的简化版本。可以想象，兔子洞会越来越深。因此，我从A到D示例的意思是试图简化情况的卷积。
例如，您要在小部件中显示和/或更改机组人员的姓名。在应用本身中，您通常会从Aircraft中选择一个Fleet（通过List索引传递到小部件），然后从CrewMember中选择一个Aircraft（通过Map键传递），然后显示/更改Name中的CrewMember。
最后，您的小部件将可以使用传入的Aircrafts索引和CrewMembers键来查看您所指的机组人员的名字。
我绝对愿意接受更好的架构和设计。
答案 0 :(得分：0)
编辑：对更新的问题的回答，以下为原始问题
目前尚不清楚A，B，C和D代表您的原始问题。原来是模型。
我目前的想法是，用MultiProvider / ProxyProvider包装您的应用以提供服务，而不是模型。
不知道如何加载数据（如果有的话），但是我假定了一项异步获取船队的服务。如果您的数据是通过零件/模型通过不同的服务加载的（而不是一次全部）加载的，则可以将其添加到MultiProvider中，并在需要加载更多数据时将它们注入适当的小部件中。
下面的示例完全可用。为了简单起见，并且由于您以更新name为例，所以我只设置了属性设置器notifyListeners()。
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
main() {
runApp(
MultiProvider(
providers: [Provider.value(value: Service())],
child: MyApp()
)
);
}
class MyApp extends StatelessWidget {
@override
Widget build(context) {
return MaterialApp(
home: Scaffold(
body: Center(
child: Consumer<Service>(
builder: (context, service, _) {
return FutureBuilder<Fleet>(
future: service.getFleet(), // might want to memoize this future
builder: (context, snapshot) {
if (snapshot.hasData) {
final member = snapshot.data.aircrafts[0].crewMembers[1];
return ShowCrewWidget(member);
} else {
return CircularProgressIndicator();
}
}
);
}
),
),
),
);
}
}
class ShowCrewWidget extends StatelessWidget {
ShowCrewWidget(this._member);
final CrewMember _member;
@override
Widget build(BuildContext context) {
return ChangeNotifierProvider<CrewMember>(
create: (_) => _member,
child: Consumer<CrewMember>(
builder: (_, model, __) {
return GestureDetector(
onDoubleTap: () => model.name = 'Peter',
child: Text(model.name)
);
},
),
);
}
}
enum Manufacturer {
Airbus, Boeing, Embraer
}
class Fleet extends ChangeNotifier {
List<Aircraft> aircrafts = [];
}
class Aircraft extends ChangeNotifier {
Manufacturer aircraftManufacturer;
double emptyWeight;
double length;
List<Seat> seats;
Map<int,CrewMember> crewMembers;
}
class CrewMember extends ChangeNotifier {
CrewMember(this._name);
String _name;
String surname;
String get name => _name;
set name(String value) {
_name = value;
notifyListeners();
}
}
class Seat extends ChangeNotifier {
int row;
Color seatColor;
}
class Service {
Future<Fleet> getFleet() {
final c1 = CrewMember('Mary');
final c2 = CrewMember('John');
final a1 = Aircraft()..crewMembers = { 0: c1, 1: c2 };
final f1 = Fleet()..aircrafts.add(a1);
return Future.delayed(Duration(seconds: 2), () => f1);
}
}
运行该应用程序，等待2秒钟以加载数据，然后您将在该地图中看到ID为1的机组人员“约翰”。然后双击文本，它应该更新为“ Peter”。
您会注意到，我正在使用服务的顶级注册（Provider.value(value: Service())）和模型的本地注册（ChangeNotifierProvider<CrewMember>(create: ...)）。
我认为这种架构（具有合理数量的模型）应该是可行的。
关于本地级别的提供程序，我觉得它有点冗长，但是可能有一些方法可以使它更简短。而且，为模型提供一些代码生成库，这些模型具有用setter通知更改的功能。
（您有C＃背景吗？我已将您的类固定为符合Dart语法。）
让我知道这是否对您有用。
如果要使用Provider，则必须使用Provider构建依赖关系图。
（您可以选择构造函数注入，而不是setter注入）
这有效：
main() {
runApp(MultiProvider(
providers: [
ChangeNotifierProvider<D>(create: (_) => D()),
ChangeNotifierProxyProvider<D, C>(
create: (_) => C(),
update: (_, d, c) => c..d=d
),
ChangeNotifierProxyProvider<C, B>(
create: (_) => B(),
update: (_, c, b) => b..c=c
),
ChangeNotifierProxyProvider<B, A>(
create: (_) => A(),
update: (_, b, a) => a..b=b
),
],
child: MyApp(),
));
}
class MyApp extends StatelessWidget {
@override
Widget build(context) {
return MaterialApp(
title: 'My Flutter App',
home: Scaffold(
body: Center(
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
Text(
'Current selected Color',
),
Consumer<D>(
builder: (context, d, _) => Placeholder(color: d.color)
),
],
),
),
floatingActionButton: FloatingActionButton(
onPressed: () => Provider.of<D>(context, listen: false).color = Colors.black,
tooltip: 'Increment',
child: Icon(Icons.arrow_forward),
),
),
);
}
}
此应用基于您的A，B，C和D类而工作。
您的示例不使用代理，因为它仅使用没有依赖性的D。但是您可以看到Provider通过以下示例正确连接了依赖项：
Consumer<A>(
builder: (context, a, _) => Text(a.b.c.d.runtimeType.toString())
),
它将打印出“ D”。
ChangeColor()不起作用，因为它没有调用notifyListeners()。
不需要在此之上使用有状态的小部件。
答案 1 :(得分：0)
正如我之前所说，您的设置似乎过于复杂。模型类的每个实例都是ChangeNotifier，因此负责维护自身。这是一个体系结构问题，将导致扩展和维护问题。
几乎每个现有的软件体系结构都有一个共同点-将状态与控制器分开。数据应该仅仅是数据。它不需要关心程序其余部分的操作。同时，控制器（块，视图模型，管理器，服务或任何您想调用的对象）提供接口，供程序的其余部分访问或修改数据。这样，我们保持了关注点的分离，并减少了服务之间的交互点数，从而大大减少了依赖关系（这对于保持程序的简单性和可维护性大有帮助。）
在这种情况下，不可变状态方法可能是一个很好的选择。在这种方法中，模型类就是不可变的。如果要更改模型中的某些内容，而不是更新字段，则换出整个模型类实例。这可能看起来很浪费，但是实际上是通过设计在状态管理中创建了几个属性：
下面是一个示例，说明如何通过不可变状态管理来表示模型类：
main() {
runApp(
ChangeNotifierProvider(
create: FleetManager(),
child: MyApp(),
),
);
}
...
class FleetManager extends ChangeNotifier {
final _fleet = <String, Aircraft>{};
Map<String, Aircraft> get fleet => Map.unmodifiable(_fleet);
void updateAircraft(String id, Aircraft aircraft) {
_fleet[id] = aircraft;
notifyListeners();
}
void removeAircraft(String id) {
_fleet.remove(id);
notifyListeners();
}
}
class Aircraft {
Aircraft({
this.aircraftManufacturer,
this.emptyWeight,
this.length,
this.seats = const {},
this.crewMembers = const {},
});
final String aircraftManufacturer;
final double emptyWeight;
final double length;
final Map<int, Seat> seats;
final Map<int, CrewMember> crewMembers;
Aircraft copyWith({
String aircraftManufacturer,
double emptyWeight,
double length,
Map<int, Seat> seats,
Map<int, CrewMember> crewMembers,
}) => Aircraft(
aircraftManufacturer: aircraftManufacturer ?? this.aircraftManufacturer,
emptyWeight: emptyWeight ?? this.emptyWeight,
length: length ?? this.length,
seats: seats ?? this.seats,
crewMembers: crewMembers ?? this.crewMembers,
);
Aircraft withSeat(int id, Seat seat) {
return Aircraft.copyWith(seats: {
...this.seats,
id: seat,
});
}
Aircraft withCrewMember(int id, CrewMember crewMember) {
return Aircraft.copyWith(seats: {
...this.crewMember,
id: seat,
});
}
}
class CrewMember {
CrewMember({
this.firstName,
this.lastName,
});
final String firstName;
final String lastName;
CrewMember copyWith({
String firstName,
String lastName,
}) => CrewMember(
firstName: firstName ?? this.firstName,
lastName: lastName ?? this.lastName,
);
}
class Seat {
Seat({
this.row,
this.seatColor,
});
final int row;
final Color seatColor;
Seat copyWith({
String row,
String seatColor,
}) => Seat(
row: row ?? this.row,
seatColor: seatColor ?? this.seatColor,
);
}
每当您要从机队中添加，修改或移除飞机时，都需要经过FleetManager，而不是各个模型。例如，如果我有一个机组人员并且想更改他们的名字，我会这样做：
final oldCrewMember = oldAircraft.crewMembers[selectedCrewMemberId];
final newCrewMember = oldCrewMember.copyWith(firstName: 'Jane');
final newAircraft = oldAircraft.withCrewMember(selectedCrewMemberId, newCrewMember);
fleetManager.updateAircraft(aircraftId, newAircraft);
当然，它比crewMember.firstName = 'Jane';更为冗长，但请考虑此处发挥的体系结构优势。使用这种方法，我们就没有相互依存的庞大网络，在任何地方进行更改都可能在其他许多地方产生影响，其中有些可能是无意的。只有一个状态，所以只有一个地方可能会发生变化。聆听此更改的所有其他信息都必须经过FleetManager，因此只需担心接口的一个问题-失败的一个问题，而不是潜在的几十个问题。有了所有这些架构安全性和简单性，代码中的更多详细信息是值得的。
这是一个简单的示例，尽管确实有一些方法可以改进它，但是仍然有一些程序包可以为我们处理这种事情。要更可靠地执行不变状态管理，建议您检出flutter_bloc或redux软件包。 redux软件包本质上是Redux在React to Flutter上的直接端口，因此，如果您有React经验，那么您会感到宾至如归。 flutter_bloc软件包对不可变状态采取了较为宽松的方法，并且还结合了有限状态机模式，这进一步降低了如何在任何给定时间判断应用程序处于何种状态的复杂性。
（还要注意，在此示例中，我将Manufacturer枚举更改为Airline类中的一个字符串字段。这是因为世界上有太多的航空公司制造商这将是一件繁琐的事情，跟不上枚举的任何制造商都无法存储在车队模型中。拥有字符串只是您需要积极维护的一件事情。）