Flutter: Comment utiliser correctement les Hérité d'un Widget?

Le problème vient de votre devis, ce qui est incorrect.

Comme vous l'avez dit, InheritedWidgets sont, comme les autres widgets, immuable. Par conséquent, ils ne sont pas mise à jour. Ils sont créés de nouveau.

La chose est : InheritedWidget est juste un widget simple qui ne fait rien mais la détention de données. Ce n'est pas une logique de mise à jour ou que ce soit.
Mais, comme n'importe quel autre widget, il est associé à un Element.
Et devinez quoi ? Cette chose est mutable et flutter va réutiliser dans la mesure du possible !

Le corrigé citation serait :

InheritedWidget référencées dans cette voie, va amener le consommateur à se reconstruire quand InheritedWidget associé à un InheritedElement changements.

Il y a un grand discours sur la façon widgets/elements/renderbox sont branché ensemble.
Mais en bref, ils sont (de gauche est typique de votre widget, le milieu est "d'éléments", et la droite sont des "render cases") :

Le truc, c'est : Lorsque vous instanciez un nouveau widget ; flutter va le comparer à l'ancien. Réutiliser c'est "l'Élément", qui pointe vers une RenderBox. Et muter la renderbox propriétés.

Okey, mais comment est-ce répondre à ma question ?

Bien, c'est facile. Lors de l'instanciation d'un InheritedWidget, et puis l'appel de context.inheritedWidgetOfExactType (ou MyClass.of qui est fondamentalement la même chose) ; ce qui est implicite, c'est qu'il sera à l'écoute des Element associé à votre InheritedWidget. Et à chaque fois que Element obtient un nouveau widget, il va forcer l'actualisation de tous les widgets qui a appelé la méthode précédente.

En bref, si vous remplacez un existant InheritedWidget avec une nouvelle marque ; flutter va voir qu'il a changé. Et le notifier à la limite des widgets d'une éventuelle modification.

Si vous avez tout compris, vous devriez déjà avoir deviné la solution :

Envelopper votre InheritedWidget à l'intérieur d'un StatefulWidget qui permettra de créer une nouvelle marque InheritedWidget chaque fois que quelque chose a changé !
Dans cette situation, il est recommandé pour votre InheritedWidget de données pour en fait juste l'exemple de votre StatefulWidget et ensuite faire InheritedWidget privé. Pour vous éviter de copier coller et de possibles erreurs.

Le résultat final réel de code serait :

class MyInherited extends StatefulWidget {
  Widget child;

  MyInherited({this.child});

  @override
  MyInheritedState createState() => new MyInheritedState();

  static MyInheritedState of(BuildContext context) {
    return (context.inheritFromWidgetOfExactType(_MyInherited) as _MyInherited).data;
  }
}

class MyInheritedState extends State<MyInherited> {
  String _myField;
  //only expose a getter to prevent bad usage
  String get myField => _myField;

  void onMyFieldChange(String newValue) {
    setState(() {
      _myField = newValue;
    });
  }

  @override
  Widget build(BuildContext context) {
    return new _MyInherited(
      data: this,
      child: widget.child,
    );
  }
}

///Only has MyInheritedState as field.
class _MyInherited extends InheritedWidget {
  final MyInheritedState data;

  _MyInherited({Key key, this.data, Widget child}) : super(key: key, child: child);

  @override
  bool updateShouldNotify(_MyInherited old) {
    return true;
  }
}

Mais ne serait pas la création d'une nouvelle InheritedWidget reconstruire l'ensemble de l'arbre ?

Pas de ne pas necesseraly. En tant que votre nouveau InheritedWidget peut avoir exactement le même enfant comme avant. Et par exact, je veux dire même instance.
Les Widgets qui ont la même instance qu'ils avaient avant de ne pas reconstruire.

Et dans la plupart des situation (le fait d'Avoir un inheritedWidget à la racine de votre application), l'héritage widget est constante. Donc pas inutile de les reconstruire.

OriginalL'auteur Rémi Rousselet

De la docs:

[BuildContext.inheritFromWidgetOfExactType] obtient le plus proche widget
d'un type donné, qui doit être le type d'un béton
InheritedWidget sous-classe, et les registres de cette construction d'un contexte avec qui
widget de telle manière que lorsque que le widget de changements (ou un nouveau widget de
de type est introduite, ou le widget s'en va), ce build contexte est
reconstruit afin qu'il puisse obtenir de nouvelles valeurs à partir de ce widget.

Ce qui est généralement appelé implicitement à partir de() les méthodes statiques, par exemple
Thème.d'.

Que l'OP a noté, une InheritedWidget instance ne change pas... mais il peut être remplacé par une nouvelle instance au même endroit dans le widget de l'arbre. Lorsque cela arrive, il est possible que le régime enregistré d'widgets besoin d'être reconstruit. Le InheritedWidget.updateShouldNotify méthode rend cette détermination. (Voir: docs)

Alors, comment pourrait-il être remplacé? Un InheritedWidget instance peut être contenue par un StatefulWidget, qui peut remplacer une ancienne version avec une nouvelle instance.

OriginalL'auteur kkurian